xsync/map_test.go at main · puzpuzpuz/xsync

2364 lines (2187 loc) · 58.6 KB
package xsync_test
	"math/rand"
	"sync/atomic"
	. "github.com/puzpuzpuz/xsync/v4"
	// number of entries to use in benchmarks
	benchmarkNumEntries = 1_000
	// key prefix used in benchmarks
	benchmarkKeyPrefix = "what_a_looooooooooooooooooooooong_key_prefix_"
type point struct {
type integerKey interface {
	int | int8 | int16 | int32 | int64 |
		uint | uint8 | uint16 | uint32 | uint64 | uintptr
var benchmarkCases = []struct {
	name           string
	readPercentage int
	{"reads=100%", 100}, // 100% loads,    0% stores,    0% deletes
	{"reads=99%", 99},   //  99% loads,  0.5% stores,  0.5% deletes
	{"reads=90%", 90},   //  90% loads,    5% stores,    5% deletes
	{"reads=75%", 75},   //  75% loads, 12.5% stores, 12.5% deletes
var benchmarkKeys []string
func init() {
	benchmarkKeys = make([]string, benchmarkNumEntries)
	for i := range benchmarkNumEntries {
		benchmarkKeys[i] = benchmarkKeyPrefix + strconv.Itoa(i)
func runParallel(b *testing.B, benchFn func(pb *testing.PB)) {
	b.ResetTimer()
	start := time.Now()
	b.RunParallel(benchFn)
	opsPerSec := float64(b.N) / float64(time.Since(start).Seconds())
	b.ReportMetric(opsPerSec, "ops/s")
func TestMap_BucketStructSize(t *testing.T) {
	size := unsafe.Sizeof(BucketPadded{})
	if size != 64 {
		t.Fatalf("size of 64B (one cache line) is expected, got: %d", size)
	size = unsafe.Sizeof(BucketPadded{})
	if size != 64 {
		t.Fatalf("size of 64B (one cache line) is expected, got: %d", size)
func TestMap_MissingEntry(t *testing.T) {
	m := NewMap[string, string]()
	v, ok := m.Load("foo")
		t.Fatalf("value was not expected: %v", v)
	if deleted, loaded := m.LoadAndDelete("foo"); loaded {
		t.Fatalf("value was not expected %v", deleted)
	if actual, loaded := m.LoadOrStore("foo", "bar"); loaded {
		t.Fatalf("value was not expected %v", actual)
func TestMap_EmptyStringKey(t *testing.T) {
	m := NewMap[string, string]()
	m.Store("", "foobar")
	v, ok := m.Load("")
		t.Fatal("value was expected")
	if v != "foobar" {
		t.Fatalf("value does not match: %v", v)
func TestMapStore_NilValue(t *testing.T) {
	m := NewMap[string, *struct{}]()
	m.Store("foo", nil)
	v, ok := m.Load("foo")
		t.Fatal("nil value was expected")
	if v != nil {
		t.Fatalf("value was not nil: %v", v)
func TestMapLoadOrStore_NilValue(t *testing.T) {
	m := NewMap[string, *struct{}]()
	m.LoadOrStore("foo", nil)
	v, loaded := m.LoadOrStore("foo", nil)
	if !loaded {
		t.Fatal("nil value was expected")
	if v != nil {
		t.Fatalf("value was not nil: %v", v)
func TestMapLoadOrStore_NonNilValue(t *testing.T) {
	type foo struct{}
	m := NewMap[string, *foo]()
	newv := &foo{}
	v, loaded := m.LoadOrStore("foo", newv)
	if loaded {
		t.Fatal("no value was expected")
	if v != newv {
		t.Fatalf("value does not match: %v", v)
	newv2 := &foo{}
	v, loaded = m.LoadOrStore("foo", newv2)
	if !loaded {
		t.Fatal("value was expected")
	if v != newv {
		t.Fatalf("value does not match: %v", v)
func TestMapLoadAndStore_NilValue(t *testing.T) {
	m := NewMap[string, *struct{}]()
	m.LoadAndStore("foo", nil)
	v, loaded := m.LoadAndStore("foo", nil)
	if !loaded {
		t.Fatal("nil value was expected")
	if v != nil {
		t.Fatalf("value was not nil: %v", v)
	v, loaded = m.Load("foo")
	if !loaded {
		t.Fatal("nil value was expected")
	if v != nil {
		t.Fatalf("value was not nil: %v", v)
func TestMapLoadAndStore_NonNilValue(t *testing.T) {
	m := NewMap[string, int]()
	v, loaded := m.LoadAndStore("foo", v1)
	if loaded {
		t.Fatal("no value was expected")
	if v != v1 {
		t.Fatalf("value does not match: %v", v)
	v, loaded = m.LoadAndStore("foo", v2)
	if !loaded {
		t.Fatal("value was expected")
	if v != v1 {
		t.Fatalf("value does not match: %v", v)
	v, loaded = m.Load("foo")
	if !loaded {
		t.Fatal("value was expected")
	if v != v2 {
		t.Fatalf("value does not match: %v", v)
func TestMapAll(t *testing.T) {
	m := NewMap[string, int]()
	for range m.All() {
		t.Fatal("got an iteration on empty map")
	for i := range 1000 {
		m.Store(strconv.Itoa(i), i)
	iters := 0
	met := make(map[string]int)
	for key, value := range m.All() {
		if key != strconv.Itoa(value) {
			t.Fatalf("got unexpected key/value for iteration %d: %v/%v", iters, key, value)
		met[key] += 1
	if iters != 1000 {
		t.Fatalf("got unexpected number of iterations: %d", iters)
	for i := range 1000 {
		if c := met[strconv.Itoa(i)]; c != 1 {
			t.Fatalf("range did not iterate correctly over %d: %d", i, c)
func TestMapAll_Break(t *testing.T) {
	m := NewMap[string, int]()
	for i := range 100 {
		m.Store(strconv.Itoa(i), i)
	iters := 0
	for range m.All() {
		if iters == 50 {
	if iters != 50 {
		t.Fatalf("got unexpected number of iterations: %d", iters)
func TestMapAll_NestedDelete(t *testing.T) {
	const numEntries = 256
	m := NewMap[string, int]()
	for i := range numEntries {
		m.Store(strconv.Itoa(i), i)
	for key := range m.All() {
		m.Delete(key)
	for i := range numEntries {
		if _, ok := m.Load(strconv.Itoa(i)); ok {
			t.Fatalf("value found for %d", i)
func TestMapRange(t *testing.T) {
	const numEntries = 1000
	m := NewMap[string, int]()
	for i := range numEntries {
		m.Store(strconv.Itoa(i), i)
	iters := 0
	met := make(map[string]int)
	m.Range(func(key string, value int) bool {
		if key != strconv.Itoa(value) {
			t.Fatalf("got unexpected key/value for iteration %d: %v/%v", iters, key, value)
			return false
		met[key] += 1
		return true
	if iters != numEntries {
		t.Fatalf("got unexpected number of iterations: %d", iters)
	for i := range numEntries {
		if c := met[strconv.Itoa(i)]; c != 1 {
			t.Fatalf("range did not iterate correctly over %d: %d", i, c)
func TestMapRange_FalseReturned(t *testing.T) {
	m := NewMap[string, int]()
	for i := range 100 {
		m.Store(strconv.Itoa(i), i)
	iters := 0
	m.Range(func(key string, value int) bool {
		if key != strconv.Itoa(value) {
			t.Fatalf("got unexpected key/value for iteration %d: %v/%v", iters, key, value)
		return iters != 13
	if iters != 13 {
		t.Fatalf("got unexpected number of iterations: %d", iters)
func TestMapRange_NestedDelete(t *testing.T) {
	const numEntries = 256
	m := NewMap[string, int]()
	for i := range numEntries {
		m.Store(strconv.Itoa(i), i)
	m.Range(func(key string, value int) bool {
		if key != strconv.Itoa(value) {
			t.Fatalf("got unexpected key/value: %v/%v", key, value)
		m.Delete(key)
		return true
	for i := range numEntries {
		if _, ok := m.Load(strconv.Itoa(i)); ok {
			t.Fatalf("value found for %d", i)
func TestMapRangeRelaxed(t *testing.T) {
	const numEntries = 1000
	m := NewMap[string, int]()
	for i := range numEntries {
		m.Store(strconv.Itoa(i), i)
	iters := 0
	met := make(map[string]int)
	m.RangeRelaxed(func(key string, value int) bool {
		if key != strconv.Itoa(value) {
			t.Fatalf("got unexpected key/value for iteration %d: %v/%v", iters, key, value)
			return false
		met[key] += 1
		return true
	if iters != numEntries {
		t.Fatalf("got unexpected number of iterations: %d", iters)
	for i := range numEntries {
		if c := met[strconv.Itoa(i)]; c != 1 {
			t.Fatalf("range did not iterate correctly over %d: %d", i, c)
func TestMapRangeRelaxed_FalseReturned(t *testing.T) {
	m := NewMap[string, int]()
	for i := range 100 {
		m.Store(strconv.Itoa(i), i)
	iters := 0
	m.RangeRelaxed(func(key string, value int) bool {
		if key != strconv.Itoa(value) {
			t.Fatalf("got unexpected key/value for iteration %d: %v/%v", iters, key, value)
		return iters != 13
	if iters != 13 {
		t.Fatalf("got unexpected number of iterations: %d", iters)
func TestMapRangeRelaxed_NestedDelete(t *testing.T) {
	const numEntries = 256
	m := NewMap[string, int]()
	for i := range numEntries {
		m.Store(strconv.Itoa(i), i)
	m.RangeRelaxed(func(key string, value int) bool {
		if key != strconv.Itoa(value) {
			t.Fatalf("got unexpected key/value: %v/%v", key, value)
		m.Delete(key)
		return true
	for i := range numEntries {
		if _, ok := m.Load(strconv.Itoa(i)); ok {
			t.Fatalf("value found for %d", i)
func TestMapAllRelaxed(t *testing.T) {
	const numEntries = 1000
	m := NewMap[string, int]()
	for i := range numEntries {
		m.Store(strconv.Itoa(i), i)
	iters := 0
	met := make(map[string]int)
	for key, value := range m.AllRelaxed() {
		if key != strconv.Itoa(value) {
			t.Fatalf("got unexpected key/value for iteration %d: %v/%v", iters, key, value)
		met[key] += 1
	if iters != numEntries {
		t.Fatalf("got unexpected number of iterations: %d", iters)
	for i := range numEntries {
		if c := met[strconv.Itoa(i)]; c != 1 {
			t.Fatalf("all did not iterate correctly over %d: %d", i, c)
func TestMapDeleteMatching(t *testing.T) {
	const numEntries = 1000
	m := NewMap[string, int]()
	for i := range numEntries {
		m.Store(strconv.Itoa(i), i)
	// Delete even values.
	deleted := m.DeleteMatching(func(key string, value int) (del, stop bool) {
		return value%2 == 0, false
	if deleted != numEntries/2 {
		t.Fatalf("expected %d deleted, got %d", numEntries/2, deleted)
	if m.Size() != numEntries/2 {
		t.Fatalf("expected size %d, got %d", numEntries/2, m.Size())
	// Verify only odd values remain.
	for i := range numEntries {
		_, ok := m.Load(strconv.Itoa(i))
		if i%2 == 0 && ok {
			t.Fatalf("even value %d should have been deleted", i)
		if i%2 != 0 && !ok {
			t.Fatalf("odd value %d should not have been deleted", i)
func TestMapDeleteMatching_Cancel(t *testing.T) {
	const numEntries = 100
	m := NewMap[string, int]()
	for i := range numEntries {
		m.Store(strconv.Itoa(i), i)
	// Delete entries and cancel after 10 deletions.
	callCount := 0
	deleted := m.DeleteMatching(func(key string, value int) (del, stop bool) {
		callCount++
		if callCount == 10 {
			return true, true // delete this one and cancel
		return true, false
	if deleted != 10 {
		t.Fatalf("expected 10 deleted, got %d", deleted)
	if callCount != 10 {
		t.Fatalf("expected f to be called 10 times, got %d", callCount)
	if m.Size() != numEntries-10 {
		t.Fatalf("expected size %d, got %d", numEntries-10, m.Size())
func TestMapDeleteMatching_EmptyMap(t *testing.T) {
	m := NewMap[string, int]()
	callCount := 0
	deleted := m.DeleteMatching(func(key string, value int) (del, stop bool) {
		callCount++
		return false, false
	if deleted != 0 {
		t.Fatalf("expected 0 deleted on empty map, got %d", deleted)
	if callCount != 0 {
		t.Fatalf("expected f to be called 0 times, got %d", callCount)
func TestMapDeleteMatching_NoDeletions(t *testing.T) {
	const numEntries = 100
	m := NewMap[string, int]()
	for i := range numEntries {
		m.Store(strconv.Itoa(i), i)
	callCount := 0
	deleted := m.DeleteMatching(func(key string, value int) (del, stop bool) {
		callCount++
		return false, false // never delete
	if deleted != 0 {
		t.Fatalf("expected 0 deleted, got %d", deleted)
	if callCount != numEntries {
		t.Fatalf("expected f to be called %d times, got %d", numEntries, callCount)
	if m.Size() != numEntries {
		t.Fatalf("expected size %d, got %d", numEntries, m.Size())
func TestMapDeleteMatching_AllDeleted(t *testing.T) {
	const numEntries = 256
	m := NewMap[string, int]()
	for i := range numEntries {
		m.Store(strconv.Itoa(i), i)
	deleted := m.DeleteMatching(func(key string, value int) (del, stop bool) {
		return true, false // delete all
	if deleted != numEntries {
		t.Fatalf("expected %d deleted, got %d", numEntries, deleted)
	if m.Size() != 0 {
		t.Fatalf("expected size 0, got %d", m.Size())
func testParallelRangeRelaxed(t *testing.T, numGoroutines int) {
	const numEntries = 10000
	const numIterations = 50
	m := NewMap[int, int]()
	for i := range numEntries {
		m.Store(i, i)
	var wg sync.WaitGroup
	var totalIterations atomic.Int64
	// Launch goroutines that iterate using RangeRelaxed.
	for range numGoroutines / 2 {
		wg.Add(1)
		go func() {
			defer wg.Done()
			for range numIterations {
				m.RangeRelaxed(func(key int, value int) bool {
					if key != value {
						t.Errorf("key %d != value %d", key, value)
					totalIterations.Add(1)
					return true
	// Launch goroutines that modify the map.
	for range numGoroutines / 2 {
		wg.Add(1)
		go func() {
			defer wg.Done()
			for range numIterations {
				for i := range numEntries {
					m.Store(i, i)
					if i%10 == 0 {
						m.Delete(i)
						m.Store(i, i)
	if totalIterations.Load() == 0 {
		t.Error("expected some iterations to occur")
func TestMapParallelRangeRelaxed(t *testing.T) {
	testParallelRangeRelaxed(t, 2)
	testParallelRangeRelaxed(t, runtime.GOMAXPROCS(0))
	testParallelRangeRelaxed(t, 100)
func testParallelDeleteMatching(t *testing.T, numGoroutines int) {
	const numEntries = 10000
	const numIterations = 50
	m := NewMap[int, int]()
	for i := range numEntries {
		m.Store(i, i)
	var wg sync.WaitGroup
	var totalDeleted atomic.Int64
	// Launch goroutines that delete even numbers.
	for range numGoroutines / 2 {
		wg.Add(1)
		go func() {
			defer wg.Done()
			for range numIterations {
				deleted := m.DeleteMatching(func(key int, value int) (del, stop bool) {
					return key%2 == 0, false
				totalDeleted.Add(int64(deleted))
	// Launch goroutines that re-add entries.
	for range numGoroutines / 2 {
		wg.Add(1)
		go func() {
			defer wg.Done()
			for range numIterations {
				for i := range numEntries {
					m.Store(i, i)
	// Verify map is in consistent state.
	size := m.Size()
	rangeCount := 0
	m.Range(func(key int, value int) bool {
		if key != value {
			t.Errorf("key %d != value %d", key, value)
		rangeCount++
		return true
	if size != rangeCount {
		t.Errorf("size %d != range count %d", size, rangeCount)
	if totalDeleted.Load() == 0 {
		t.Error("expected some deletions to occur")
func TestMapParallelDeleteMatching(t *testing.T) {
	testParallelDeleteMatching(t, 2)
	testParallelDeleteMatching(t, runtime.GOMAXPROCS(0))
	testParallelDeleteMatching(t, 100)
func TestMapDeleteMatching_ConcurrentResize(t *testing.T) {
	// This test attempts to cover the resize paths in DeleteMatching:
	// 1. Resize in progress during DeleteMatching iteration
	// 2. Table changed (resize completed) during DeleteMatching iteration
	const numIterations = 1000
	const numEntries = 100
	for iter := range numIterations {
		// Start with minimal size to maximize resize frequency
		m := NewMap[int, int]()
		// Pre-fill just enough to have entries
		for i := range numEntries {
			m.Store(i, i)
		var wg sync.WaitGroup
		start := make(chan struct{})
		// Goroutines that trigger resize by adding many new entries
		for range 8 {
			wg.Add(1)
			go func() {
				defer wg.Done()
				<-start
				for i := numEntries; i < numEntries*10; i++ {
					m.Store(i, i)
		// Goroutines that call DeleteMatching repeatedly during resize
		for range 8 {
			wg.Add(1)
			go func() {
				defer wg.Done()
				<-start
				for range 10 {
					m.DeleteMatching(func(key int, value int) (del, stop bool) {
						return key%5 == 0, false
		// Start all goroutines simultaneously
		close(start)
		wg.Wait()
		// Verify map consistency
		size := m.Size()
		rangeCount := 0
		m.Range(func(key int, value int) bool {
			rangeCount++
			return true
		if size != rangeCount {
			t.Errorf("iteration %d: size %d != range count %d", iter, size, rangeCount)
func testMapStoreKeys[K integerKey](t *testing.T, numEntries int) {
	t.Helper()
	m := NewMap[K, K]()
	for i := range numEntries {
		m.Store(K(i), K(i))
	for i := range numEntries {
		v, ok := m.Load(K(i))
			t.Fatalf("value not found for %d", i)
		if v != K(i) {
			t.Fatalf("values do not match for %d: %v", i, v)
func TestMapStore_TypedKeys(t *testing.T) {
	const n = 128
	t.Run("int", func(t *testing.T) { testMapStoreKeys[int](t, n) })
	t.Run("uint", func(t *testing.T) { testMapStoreKeys[uint](t, n) })
	t.Run("int8", func(t *testing.T) { testMapStoreKeys[int8](t, n) })
	t.Run("uint8", func(t *testing.T) { testMapStoreKeys[uint8](t, n) })
	t.Run("int16", func(t *testing.T) { testMapStoreKeys[int16](t, n) })
	t.Run("uint16", func(t *testing.T) { testMapStoreKeys[uint16](t, n) })
	t.Run("int32", func(t *testing.T) { testMapStoreKeys[int32](t, n) })
	t.Run("uint32", func(t *testing.T) { testMapStoreKeys[uint32](t, n) })
	t.Run("int64", func(t *testing.T) { testMapStoreKeys[int64](t, n) })
	t.Run("uint64", func(t *testing.T) { testMapStoreKeys[uint64](t, n) })
	t.Run("uintptr", func(t *testing.T) { testMapStoreKeys[uintptr](t, n) })
	t.Run("string", func(t *testing.T) {
		m := NewMap[string, int]()
		for i := range n {
			m.Store(strconv.Itoa(i), i)
		for i := range n {
			v, ok := m.Load(strconv.Itoa(i))
			if !ok {
				t.Fatalf("value not found for %d", i)
			if v != i {
				t.Fatalf("values do not match for %d: %v", i, v)
	t.Run("struct_intValues", func(t *testing.T) {
		m := NewMap[point, int]()
		for i := range n {
			m.Store(point{int32(i), -int32(i)}, i)
		for i := range n {
			v, ok := m.Load(point{int32(i), -int32(i)})
			if !ok {
				t.Fatalf("value not found for %d", i)
			if v != i {
				t.Fatalf("values do not match for %d: %v", i, v)
	t.Run("struct_structValues", func(t *testing.T) {
		m := NewMap[point, point]()
		for i := range n {
			m.Store(point{int32(i), -int32(i)}, point{-int32(i), int32(i)})
		for i := range n {
			v, ok := m.Load(point{int32(i), -int32(i)})
			if !ok {
				t.Fatalf("value not found for %d", i)
			if v.x != -int32(i) {
				t.Fatalf("x value does not match for %d: %v", i, v)
			if v.y != int32(i) {
				t.Fatalf("y value does not match for %d: %v", i, v)
func TestMapLoadOrStore(t *testing.T) {
	const numEntries = 1000
	m := NewMap[string, int]()
	for i := range numEntries {
		m.Store(strconv.Itoa(i), i)
	for i := range numEntries {
		if _, loaded := m.LoadOrStore(strconv.Itoa(i), i); !loaded {
			t.Fatalf("value not found for %d", i)
func TestMapLoadOrCompute(t *testing.T) {
	const numEntries = 1000
	m := NewMap[string, int]()
	for i := range numEntries {
		v, loaded := m.LoadOrCompute(strconv.Itoa(i), func() (newValue int, cancel bool) {
			return i, true
		if loaded {
			t.Fatalf("value not computed for %d", i)
		if v != 0 {
			t.Fatalf("values do not match for %d: %v", i, v)
	if m.Size() != 0 {
		t.Fatalf("zero map size expected: %d", m.Size())
	for i := range numEntries {
		v, loaded := m.LoadOrCompute(strconv.Itoa(i), func() (newValue int, cancel bool) {
			return i, false
		if loaded {
			t.Fatalf("value not computed for %d", i)
		if v != i {
			t.Fatalf("values do not match for %d: %v", i, v)
	for i := range numEntries {
		v, loaded := m.LoadOrCompute(strconv.Itoa(i), func() (newValue int, cancel bool) {
			t.Fatalf("value func invoked")
			return newValue, false
		if !loaded {
			t.Fatalf("value not loaded for %d", i)
		if v != i {
			t.Fatalf("values do not match for %d: %v", i, v)
func TestMapLoadOrCompute_FunctionCalledOnce(t *testing.T) {
	m := NewMap[int, int]()
	for i := 0; i < 100; {
		m.LoadOrCompute(i, func() (newValue int, cancel bool) {
			newValue, i = i, i+1
			return newValue, false
	m.Range(func(k, v int) bool {
		if k != v {
			t.Fatalf("%dth key is not equal to value %d", k, v)
		return true
func TestMapLoadOrCompute_ExistingKey(t *testing.T) {
	m := NewMap[string, int]()
	m.Store("key", 42)
	v, loaded := m.LoadOrCompute("key", func() (int, bool) {
		t.Fatal("value func should not be called for existing key")
		return 100, false
	if !loaded {
		t.Fatal("expected loaded to be true")
	if v != 42 {
		t.Fatalf("expected value 42, got %d", v)
func TestMapLoadOrCompute_ConcurrentExistingKey(t *testing.T) {
	// This test attempts to cover the race condition where:
	// 1. LoadOrCompute's fast path doesn't find the key
	// 2. Another goroutine inserts the key
	// 3. LoadOrCompute acquires the lock and finds the key
	const numIters = 10000
	for range numIters {
		m := NewMap[int, int]()
		var wg sync.WaitGroup
		wg.Add(2)
		go func() {
			defer wg.Done()
			m.Store(1, 42)
		go func() {
			defer wg.Done()
			m.LoadOrCompute(1, func() (int, bool) {
				return 100, false
		wg.Wait()
		v, ok := m.Load(1)
			t.Fatal("key should exist")
		if v != 42 && v != 100 {
			t.Fatalf("unexpected value: %d", v)
func TestMapOfCompute(t *testing.T) {
	m := NewMap[string, int]()
	// Store a new value.
	v, ok := m.Compute("foobar", func(oldValue int, loaded bool) (newValue int, op ComputeOp) {
		if oldValue != 0 {
			t.Fatalf("oldValue should be 0 when computing a new value: %d", oldValue)
		if loaded {
			t.Fatal("loaded should be false when computing a new value")
		newValue = 42
		op = UpdateOp
	if v != 42 {
		t.Fatalf("v should be 42 when computing a new value: %d", v)
		t.Fatal("ok should be true when computing a new value")
	// Update an existing value.
	v, ok = m.Compute("foobar", func(oldValue int, loaded bool) (newValue int, op ComputeOp) {
		if oldValue != 42 {
			t.Fatalf("oldValue should be 42 when updating the value: %d", oldValue)
		if !loaded {
			t.Fatal("loaded should be true when updating the value")
		newValue = oldValue + 42
		op = UpdateOp
	if v != 84 {
		t.Fatalf("v should be 84 when updating the value: %d", v)
		t.Fatal("ok should be true when updating the value")
	// Check that NoOp doesn't update the value
	v, ok = m.Compute("foobar", func(oldValue int, loaded bool) (newValue int, op ComputeOp) {
		return 0, CancelOp
	if v != 84 {
		t.Fatalf("v should be 84 after using NoOp: %d", v)
		t.Fatal("ok should be true when updating the value")
	// Delete an existing value.
	v, ok = m.Compute("foobar", func(oldValue int, loaded bool) (newValue int, op ComputeOp) {
		if oldValue != 84 {
			t.Fatalf("oldValue should be 84 when deleting the value: %d", oldValue)
		if !loaded {
			t.Fatal("loaded should be true when deleting the value")
		op = DeleteOp
	if v != 84 {
		t.Fatalf("v should be 84 when deleting the value: %d", v)
		t.Fatal("ok should be false when deleting the value")
	// Try to delete a non-existing value. Notice different key.
	v, ok = m.Compute("barbaz", func(oldValue int, loaded bool) (newValue int, op ComputeOp) {
		if oldValue != 0 {
			t.Fatalf("oldValue should be 0 when trying to delete a non-existing value: %d", oldValue)
		if loaded {
			t.Fatal("loaded should be false when trying to delete a non-existing value")
		// We're returning a non-zero value, but the map should ignore it.
		newValue = 42
		op = DeleteOp
	if v != 0 {
		t.Fatalf("v should be 0 when trying to delete a non-existing value: %d", v)
		t.Fatal("ok should be false when trying to delete a non-existing value")
	// Try NoOp on a non-existing value
	v, ok = m.Compute("barbaz", func(oldValue int, loaded bool) (newValue int, op ComputeOp) {
		if oldValue != 0 {
			t.Fatalf("oldValue should be 0 when trying to delete a non-existing value: %d", oldValue)
		if loaded {
			t.Fatal("loaded should be false when trying to delete a non-existing value")
		// We're returning a non-zero value, but the map should ignore it.
		newValue = 42
		op = CancelOp
	if v != 0 {
View remainder of file in raw view
Provide feedback

Saved searches

Use saved searches to filter your results more quickly

FilesExpand file tree

map_test.go

Latest commit

History

map_test.go

File metadata and controls
