...
Run Format

Source file src/sync/map_test.go

Documentation: sync

  // Copyright 2016 The Go Authors. All rights reserved.
  // Use of this source code is governed by a BSD-style
  // license that can be found in the LICENSE file.
  
  package sync_test
  
  import (
  	"math/rand"
  	"reflect"
  	"runtime"
  	"sync"
  	"testing"
  	"testing/quick"
  )
  
  type mapOp string
  
  const (
  	opLoad        = mapOp("Load")
  	opStore       = mapOp("Store")
  	opLoadOrStore = mapOp("LoadOrStore")
  	opDelete      = mapOp("Delete")
  )
  
  var mapOps = [...]mapOp{opLoad, opStore, opLoadOrStore, opDelete}
  
  // mapCall is a quick.Generator for calls on mapInterface.
  type mapCall struct {
  	op   mapOp
  	k, v interface{}
  }
  
  func (c mapCall) apply(m mapInterface) (interface{}, bool) {
  	switch c.op {
  	case opLoad:
  		return m.Load(c.k)
  	case opStore:
  		m.Store(c.k, c.v)
  		return nil, false
  	case opLoadOrStore:
  		return m.LoadOrStore(c.k, c.v)
  	case opDelete:
  		m.Delete(c.k)
  		return nil, false
  	default:
  		panic("invalid mapOp")
  	}
  }
  
  type mapResult struct {
  	value interface{}
  	ok    bool
  }
  
  func randValue(r *rand.Rand) interface{} {
  	b := make([]byte, r.Intn(4))
  	for i := range b {
  		b[i] = 'a' + byte(rand.Intn(26))
  	}
  	return string(b)
  }
  
  func (mapCall) Generate(r *rand.Rand, size int) reflect.Value {
  	c := mapCall{op: mapOps[rand.Intn(len(mapOps))], k: randValue(r)}
  	switch c.op {
  	case opStore, opLoadOrStore:
  		c.v = randValue(r)
  	}
  	return reflect.ValueOf(c)
  }
  
  func applyCalls(m mapInterface, calls []mapCall) (results []mapResult, final map[interface{}]interface{}) {
  	for _, c := range calls {
  		v, ok := c.apply(m)
  		results = append(results, mapResult{v, ok})
  	}
  
  	final = make(map[interface{}]interface{})
  	m.Range(func(k, v interface{}) bool {
  		final[k] = v
  		return true
  	})
  
  	return results, final
  }
  
  func applyMap(calls []mapCall) ([]mapResult, map[interface{}]interface{}) {
  	return applyCalls(new(sync.Map), calls)
  }
  
  func applyRWMutexMap(calls []mapCall) ([]mapResult, map[interface{}]interface{}) {
  	return applyCalls(new(RWMutexMap), calls)
  }
  
  func applyDeepCopyMap(calls []mapCall) ([]mapResult, map[interface{}]interface{}) {
  	return applyCalls(new(DeepCopyMap), calls)
  }
  
  func TestMapMatchesRWMutex(t *testing.T) {
  	if err := quick.CheckEqual(applyMap, applyRWMutexMap, nil); err != nil {
  		t.Error(err)
  	}
  }
  
  func TestMapMatchesDeepCopy(t *testing.T) {
  	if err := quick.CheckEqual(applyMap, applyDeepCopyMap, nil); err != nil {
  		t.Error(err)
  	}
  }
  
  func TestConcurrentRange(t *testing.T) {
  	const mapSize = 1 << 10
  
  	m := new(sync.Map)
  	for n := int64(1); n <= mapSize; n++ {
  		m.Store(n, int64(n))
  	}
  
  	done := make(chan struct{})
  	var wg sync.WaitGroup
  	defer func() {
  		close(done)
  		wg.Wait()
  	}()
  	for g := int64(runtime.GOMAXPROCS(0)); g > 0; g-- {
  		r := rand.New(rand.NewSource(g))
  		wg.Add(1)
  		go func(g int64) {
  			defer wg.Done()
  			for i := int64(0); ; i++ {
  				select {
  				case <-done:
  					return
  				default:
  				}
  				for n := int64(1); n < mapSize; n++ {
  					if r.Int63n(mapSize) == 0 {
  						m.Store(n, n*i*g)
  					} else {
  						m.Load(n)
  					}
  				}
  			}
  		}(g)
  	}
  
  	iters := 1 << 10
  	if testing.Short() {
  		iters = 16
  	}
  	for n := iters; n > 0; n-- {
  		seen := make(map[int64]bool, mapSize)
  
  		m.Range(func(ki, vi interface{}) bool {
  			k, v := ki.(int64), vi.(int64)
  			if v%k != 0 {
  				t.Fatalf("while Storing multiples of %v, Range saw value %v", k, v)
  			}
  			if seen[k] {
  				t.Fatalf("Range visited key %v twice", k)
  			}
  			seen[k] = true
  			return true
  		})
  
  		if len(seen) != mapSize {
  			t.Fatalf("Range visited %v elements of %v-element Map", len(seen), mapSize)
  		}
  	}
  }
  

View as plain text