libgo/go/sync/map_test.go

   1 // Copyright 2016 The Go Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style
   3 // license that can be found in the LICENSE file.
   4
   5 package sync_test
   6
   7 import (
   8         "math/rand"
   9         "reflect"
  10         "runtime"
  11         "sync"
  12         "testing"
  13         "testing/quick"
  14 )
  15
  16 type mapOp string
  17
  18 const (
  19         opLoad        = mapOp("Load")
  20         opStore       = mapOp("Store")
  21         opLoadOrStore = mapOp("LoadOrStore")
  22         opDelete      = mapOp("Delete")
  23 )
  24
  25 var mapOps = [...]mapOp{opLoad, opStore, opLoadOrStore, opDelete}
  26
  27 // mapCall is a quick.Generator for calls on mapInterface.
  28 type mapCall struct {
  29         op   mapOp
  30         k, v interface{}
  31 }
  32
  33 func (c mapCall) apply(m mapInterface) (interface{}, bool) {
  34         switch c.op {
  35         case opLoad:
  36                 return m.Load(c.k)
  37         case opStore:
  38                 m.Store(c.k, c.v)
  39                 return nil, false
  40         case opLoadOrStore:
  41                 return m.LoadOrStore(c.k, c.v)
  42         case opDelete:
  43                 m.Delete(c.k)
  44                 return nil, false
  45         default:
  46                 panic("invalid mapOp")
  47         }
  48 }
  49
  50 type mapResult struct {
  51         value interface{}
  52         ok    bool
  53 }
  54
  55 func randValue(r *rand.Rand) interface{} {
  56         b := make([]byte, r.Intn(4))
  57         for i := range b {
  58                 b[i] = 'a' + byte(rand.Intn(26))
  59         }
  60         return string(b)
  61 }
  62
  63 func (mapCall) Generate(r *rand.Rand, size int) reflect.Value {
  64         c := mapCall{op: mapOps[rand.Intn(len(mapOps))], k: randValue(r)}
  65         switch c.op {
  66         case opStore, opLoadOrStore:
  67                 c.v = randValue(r)
  68         }
  69         return reflect.ValueOf(c)
  70 }
  71
  72 func applyCalls(m mapInterface, calls []mapCall) (results []mapResult, final map[interface{}]interface{}) {
  73         for _, c := range calls {
  74                 v, ok := c.apply(m)
  75                 results = append(results, mapResult{v, ok})
  76         }
  77
  78         final = make(map[interface{}]interface{})
  79         m.Range(func(k, v interface{}) bool {
  80                 final[k] = v
  81                 return true
  82         })
  83
  84         return results, final
  85 }
  86
  87 func applyMap(calls []mapCall) ([]mapResult, map[interface{}]interface{}) {
  88         return applyCalls(new(sync.Map), calls)
  89 }
  90
  91 func applyRWMutexMap(calls []mapCall) ([]mapResult, map[interface{}]interface{}) {
  92         return applyCalls(new(RWMutexMap), calls)
  93 }
  94
  95 func applyDeepCopyMap(calls []mapCall) ([]mapResult, map[interface{}]interface{}) {
  96         return applyCalls(new(DeepCopyMap), calls)
  97 }
  98
  99 func TestMapMatchesRWMutex(t *testing.T) {
 100         if err := quick.CheckEqual(applyMap, applyRWMutexMap, nil); err != nil {
 101                 t.Error(err)
 102         }
 103 }
 104
 105 func TestMapMatchesDeepCopy(t *testing.T) {
 106         if err := quick.CheckEqual(applyMap, applyDeepCopyMap, nil); err != nil {
 107                 t.Error(err)
 108         }
 109 }
 110
 111 func TestConcurrentRange(t *testing.T) {
 112         const mapSize = 1 << 10
 113
 114         m := new(sync.Map)
 115         for n := int64(1); n <= mapSize; n++ {
 116                 m.Store(n, int64(n))
 117         }
 118
 119         done := make(chan struct{})
 120         var wg sync.WaitGroup
 121         defer func() {
 122                 close(done)
 123                 wg.Wait()
 124         }()
 125         for g := int64(runtime.GOMAXPROCS(0)); g > 0; g-- {
 126                 r := rand.New(rand.NewSource(g))
 127                 wg.Add(1)
 128                 go func(g int64) {
 129                         defer wg.Done()
 130                         for i := int64(0); ; i++ {
 131                                 select {
 132                                 case <-done:
 133                                         return
 134                                 default:
 135                                 }
 136                                 for n := int64(1); n < mapSize; n++ {
 137                                         if r.Int63n(mapSize) == 0 {
 138                                                 m.Store(n, n*i*g)
 139                                         } else {
 140                                                 m.Load(n)
 141                                         }
 142                                 }
 143                         }
 144                 }(g)
 145         }
 146
 147         iters := 1 << 10
 148         if testing.Short() {
 149                 iters = 16
 150         }
 151         for n := iters; n > 0; n-- {
 152                 seen := make(map[int64]bool, mapSize)
 153
 154                 m.Range(func(ki, vi interface{}) bool {
 155                         k, v := ki.(int64), vi.(int64)
 156                         if v%k != 0 {
 157                                 t.Fatalf("while Storing multiples of %v, Range saw value %v", k, v)
 158                         }
 159                         if seen[k] {
 160                                 t.Fatalf("Range visited key %v twice", k)
 161                         }
 162                         seen[k] = true
 163                         return true
 164                 })
 165
 166                 if len(seen) != mapSize {
 167                         t.Fatalf("Range visited %v elements of %v-element Map", len(seen), mapSize)
 168                 }
 169         }
 170 }