gitee.com/go-spring2/spring-base@v1.1.3/knife/knife_test.go (about)

     1  /*
     2   * Copyright 2012-2019 the original author or authors.
     3   *
     4   * Licensed under the Apache License, Version 2.0 (the "License");
     5   * you may not use this file except in compliance with the License.
     6   * You may obtain a copy of the License at
     7   *
     8   *      https://www.apache.org/licenses/LICENSE-2.0
     9   *
    10   * Unless required by applicable law or agreed to in writing, software
    11   * distributed under the License is distributed on an "AS IS" BASIS,
    12   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
    13   * See the License for the specific language governing permissions and
    14   * limitations under the License.
    15   */
    16  
    17  package knife_test
    18  
    19  import (
    20  	"context"
    21  	"strconv"
    22  	"sync"
    23  	"testing"
    24  
    25  	"gitee.com/go-spring2/spring-base/assert"
    26  	"gitee.com/go-spring2/spring-base/knife"
    27  )
    28  
    29  func TestKnife(t *testing.T) {
    30  	ctx := context.Background()
    31  
    32  	v, err := knife.Load(ctx, "a")
    33  	assert.Error(t, err, "knife uninitialized")
    34  
    35  	err = knife.Store(ctx, "a", "b")
    36  	assert.Error(t, err, "knife uninitialized")
    37  
    38  	_, _, err = knife.LoadOrStore(ctx, "a", 3)
    39  	assert.Error(t, err, "knife uninitialized")
    40  
    41  	ctx, cached := knife.New(ctx)
    42  	assert.False(t, cached)
    43  
    44  	v, err = knife.Load(ctx, "a")
    45  	assert.Nil(t, err)
    46  	assert.Nil(t, v)
    47  
    48  	err = knife.Store(ctx, "a", "b")
    49  	assert.Nil(t, err)
    50  
    51  	err = knife.Store(ctx, "a", "c")
    52  	assert.Error(t, err, "duplicate key \"a\"")
    53  
    54  	v, err = knife.Load(ctx, "a")
    55  	assert.Nil(t, err)
    56  	assert.Equal(t, v, "b")
    57  
    58  	{
    59  		var keys []interface{}
    60  		knife.Range(ctx, func(key, value interface{}) bool {
    61  			keys = append(keys, key)
    62  			return true
    63  		})
    64  		assert.Equal(t, keys, []interface{}{"a"})
    65  	}
    66  
    67  	ctx, cached = knife.New(ctx)
    68  	assert.True(t, cached)
    69  
    70  	v, err = knife.Load(ctx, "a")
    71  	assert.Nil(t, err)
    72  	assert.Equal(t, v, "b")
    73  
    74  	knife.Delete(ctx, "a")
    75  	{
    76  		var keys []interface{}
    77  		knife.Range(ctx, func(key, value interface{}) bool {
    78  			keys = append(keys, key)
    79  			return true
    80  		})
    81  		assert.Equal(t, keys, []interface{}(nil))
    82  	}
    83  
    84  	var (
    85  		wg sync.WaitGroup
    86  		m  sync.Mutex
    87  		r  [][]interface{}
    88  	)
    89  	wg.Add(3)
    90  	for i := 0; i < 3; i++ {
    91  		val := strconv.Itoa(i)
    92  		go func() {
    93  			defer wg.Done()
    94  			actual, loaded, _ := knife.LoadOrStore(ctx, "a", val)
    95  			m.Lock()
    96  			defer m.Unlock()
    97  			r = append(r, []interface{}{actual, loaded})
    98  		}()
    99  	}
   100  	wg.Wait()
   101  	{
   102  		count := 0
   103  		var actual interface{}
   104  		for i := 0; i < len(r); i++ {
   105  			if r[i][1] == true {
   106  				actual = r[i][0]
   107  				count++
   108  			}
   109  		}
   110  		assert.Equal(t, count, 2)
   111  		for i := 0; i < len(r); i++ {
   112  			assert.Equal(t, r[i][0], actual)
   113  		}
   114  	}
   115  }