sync_map_test.go

package syncmap_test

import (
	"sync"
	"testing"

	"github.com/stretchr/testify/require"
	"github.com/yylego/syncmap"
)

func TestMap_New(t *testing.T) {
	// Test both New and NewMap functions
	m1 := syncmap.New[string, int]()
	m2 := syncmap.NewMap[string, int]()
	require.NotNil(t, m1, "New must return non-nil Map")
	require.NotNil(t, m2, "NewMap must return non-nil Map")

	// Check empty state at start
	_, ok := m1.Load("test")
	require.False(t, ok, "New Map must have no items")
	_, ok = m2.Load("test")
	require.False(t, ok, "NewMap must have no items")
}

func TestMap_StoreAndLoad(t *testing.T) {
	m := syncmap.NewMap[string, float64]()
	m.Store("pi", 3.14)

	value, ok := m.Load("pi")
	require.True(t, ok, "Load must return true when item exists")
	require.Equal(t, 3.14, value, "Load must return the stored value")

	_, ok = m.Load("unknown")
	require.False(t, ok, "Load must return false when item not found")
}

func TestMap_Store(t *testing.T) {
	var mp = syncmap.NewMap[string, int]()
	mp.Store("a", 1)
	value, ok := mp.Load("a")
	t.Log(ok)
	require.True(t, ok)
	t.Log(value)
	require.Equal(t, 1, value)
	t.Log(value + value) // 这里返回 int 结果，可以按照 int 使用
	t.Log(value * 2)     // 可以使用乘法操作，无需 interface{} 类型转换
}

func TestMap_Delete(t *testing.T) {
	m := syncmap.NewMap[int, string]()
	m.Store(1, "one")

	m.Delete(1)
	_, ok := m.Load(1)
	require.False(t, ok, "Delete must remove the item")

	// Deleting non-existing item does not panic
	m.Delete(2)
	_, ok = m.Load(2)
	require.False(t, ok, "Deleting non-existing item has no effect")
}

func TestMap_LoadOrStore(t *testing.T) {
	m := syncmap.NewMap[string, bool]()

	// Store new item
	value, loaded := m.LoadOrStore("active", true)
	require.False(t, loaded, "LoadOrStore must return false when item is new")
	require.True(t, value, "LoadOrStore must return the stored value")

	// Load existing item
	value, loaded = m.LoadOrStore("active", false)
	require.True(t, loaded, "LoadOrStore must return true when item exists")
	require.True(t, value, "LoadOrStore must return the existing value")
}

func TestMap_LoadAndDelete(t *testing.T) {
	m := syncmap.NewMap[int, string]()
	m.Store(42, "answer")

	value, ok := m.LoadAndDelete(42)
	require.True(t, ok, "LoadAndDelete must return true when item exists")
	require.Equal(t, "answer", value, "LoadAndDelete must return the item value")
	_, ok = m.Load(42)
	require.False(t, ok, "Item must be gone")

	value, ok = m.LoadAndDelete(99)
	require.False(t, ok, "LoadAndDelete must return false when item not found")
	require.Equal(t, "", value, "LoadAndDelete must return zero value when not found")
}

func TestMap_Swap(t *testing.T) {
	m := syncmap.NewMap[string, int]()
	m.Store("count", 10)

	t.Run("existing item", func(t *testing.T) {
		previous, ok := m.Swap("count", 20)
		require.True(t, ok, "Swap must return true when item exists")
		require.Equal(t, 10, previous, "Swap must return the old value")
		value, _ := m.Load("count")
		require.Equal(t, 20, value, "New value must be set")
	})

	t.Run("non-existing item", func(t *testing.T) {
		previous, ok := m.Swap("new", 30)
		require.False(t, ok, "Swap must return false when item not found")
		require.Equal(t, 0, previous)
		value, ok := m.Load("new")
		require.True(t, ok, "Item must exist now")
		require.Equal(t, 30, value, "New value must be set")
	})
}

func TestMap_CompareAndSwap(t *testing.T) {
	m := syncmap.NewMap[string, string]()
	m.Store("color", "blue")

	t.Run("wrong value", func(t *testing.T) {
		result := m.CompareAndSwap("color", "red", "green")
		require.False(t, result, "CompareAndSwap must fail when old value is wrong")
		value, _ := m.Load("color")
		require.Equal(t, "blue", value, "Value must stay the same")
	})

	t.Run("correct value", func(t *testing.T) {
		result := m.CompareAndSwap("color", "blue", "green")
		require.True(t, result, "CompareAndSwap must succeed when old value matches")
		value, _ := m.Load("color")
		require.Equal(t, "green", value, "Value must be swapped")
	})
}

func TestMap_CompareAndDelete(t *testing.T) {
	m := syncmap.NewMap[string, int]()
	m.Store("x", 100)

	t.Run("wrong value", func(t *testing.T) {
		result := m.CompareAndDelete("x", 200)
		require.False(t, result, "CompareAndDelete must fail when value is wrong")
		_, ok := m.Load("x")
		require.True(t, ok, "Item must still exist")
	})

	t.Run("correct value", func(t *testing.T) {
		result := m.CompareAndDelete("x", 100)
		require.True(t, result, "CompareAndDelete must succeed when value matches")
		_, ok := m.Load("x")
		require.False(t, ok, "Item must be gone")
	})
}

func TestMap_Range(t *testing.T) {
	m := syncmap.NewMap[string, int]()
	m.Store("a", 1)
	m.Store("b", 2)

	count := 0
	m.Range(func(k string, v int) bool {
		count++
		switch k {
		case "a":
			require.Equal(t, 1, v, "Range must give the value 1 when visiting 'a'")
		case "b":
			require.Equal(t, 2, v, "Range must give the value 2 when visiting 'b'")
		default:
			t.Errorf("Unexpected item: %v", k)
		}
		return true
	})
	require.Equal(t, 2, count, "Range must visit both items")
}

func TestSyncMap(t *testing.T) {
	// 创建一个 sync.Map 对象
	var m sync.Map

	// 测试 Store 和 Load 方法
	m.Store("foo", 1)
	if v, ok := m.Load("foo"); !ok || v.(int) != 1 {
		t.Errorf("Load failed: %v, %v", v, ok)
	}

	// 测试 LoadOrStore 方法
	if v, ok := m.LoadOrStore("bar", 2); ok || v.(int) != 2 {
		t.Errorf("LoadOrStore failed: %v, %v", v, ok)
	}
	if v, ok := m.LoadOrStore("foo", 3); !ok || v.(int) != 1 {
		t.Errorf("LoadOrStore failed: %v, %v", v, ok)
	}

	// 测试 Range 方法
	m.Store("baz", 3)
	m.Range(func(k, v interface{}) bool {
		switch k {
		case "foo":
			if v.(int) != 1 {
				t.Errorf("Range failed: %v", v)
			}
		case "bar":
			if v.(int) != 2 {
				t.Errorf("Range failed: %v", v)
			}
		case "baz":
			if v.(int) != 3 {
				t.Errorf("Range failed: %v", v)
			}
		default:
			t.Errorf("Range failed: unexpected key %v", k)
		}
		return true
	})

	// 测试 Delete 方法
	m.Delete("foo")
	if _, ok := m.Load("foo"); ok {
		t.Errorf("Delete failed")
	}
}

func TestSyncMap2(t *testing.T) {
	// 创建一个 sync.Map 对象
	var m sync.Map

	// 测试 Store 和 Load 方法
	m.Store("foo", 1)
	if v, ok := m.Load("foo"); !ok || v.(int) != 1 {
		t.Errorf("Load failed: %v, %v", v, ok)
	}

	// 测试 LoadOrStore 方法
	if v, ok := m.LoadOrStore("bar", 2); ok || v.(int) != 2 {
		t.Errorf("LoadOrStore failed: %v, %v", v, ok)
	}
	if v, ok := m.LoadOrStore("foo", 3); !ok || v.(int) != 1 {
		t.Errorf("LoadOrStore failed: %v, %v", v, ok)
	}

	// 测试 Range 方法
	m.Store("baz", 3)
	var keys []string
	var values []int
	m.Range(func(k, v interface{}) bool {
		keys = append(keys, k.(string))
		values = append(values, v.(int))
		return true
	})

	if len(keys) != 3 || len(values) != 3 {
		t.Errorf("Range failed: %v, %v", keys, values)
	}
	if !containsValue(keys, "foo") || !containsValue(keys, "bar") || !containsValue(keys, "baz") {
		t.Errorf("Range failed: %v", keys)
	}
	if !containsValue(values, 1) || !containsValue(values, 2) || !containsValue(values, 3) {
		t.Errorf("Range failed: %v", values)
	}

	// 测试 Delete 方法
	m.Delete("foo")
	if _, ok := m.Load("foo"); ok {
		t.Errorf("Delete failed")
	}
}

func TestSyncMap3(t *testing.T) {
	// 创建一个 sync.Map 对象
	var m = syncmap.NewMap[string, int]()

	// 测试 Store 和 Load 方法
	m.Store("foo", 1)
	if v, ok := m.Load("foo"); !ok || v != 1 {
		t.Errorf("Load failed: %v, %v", v, ok)
	}

	// 测试 LoadOrStore 方法
	if v, ok := m.LoadOrStore("bar", 2); ok || v != 2 {
		t.Errorf("LoadOrStore failed: %v, %v", v, ok)
	}
	if v, ok := m.LoadOrStore("foo", 3); !ok || v != 1 {
		t.Errorf("LoadOrStore failed: %v, %v", v, ok)
	}

	// 测试 Range 方法
	m.Store("baz", 3)
	m.Range(func(k string, v int) bool {
		switch k {
		case "foo":
			if v != 1 {
				t.Errorf("Range failed: %v", v)
			}
		case "bar":
			if v != 2 {
				t.Errorf("Range failed: %v", v)
			}
		case "baz":
			if v != 3 {
				t.Errorf("Range failed: %v", v)
			}
		default:
			t.Errorf("Range failed: unexpected key %v", k)
		}
		return true
	})

	// 测试 Delete 方法
	m.Delete("foo")
	if _, ok := m.Load("foo"); ok {
		t.Errorf("Delete failed")
	}
}

func TestSyncMap4(t *testing.T) {
	// 创建一个 sync.Map 对象
	var m = syncmap.NewMap[string, int64]()

	// 测试 Store 和 Load 方法
	m.Store("foo", 1)
	if v, ok := m.Load("foo"); !ok || v != 1 {
		t.Errorf("Load failed: %v, %v", v, ok)
	}

	// 测试 LoadOrStore 方法
	if v, ok := m.LoadOrStore("bar", 2); ok || v != 2 {
		t.Errorf("LoadOrStore failed: %v, %v", v, ok)
	}
	if v, ok := m.LoadOrStore("foo", 3); !ok || v != 1 {
		t.Errorf("LoadOrStore failed: %v, %v", v, ok)
	}

	// 测试 Range 方法
	m.Store("baz", 3)
	var keys []string
	var values []int64
	m.Range(func(k string, v int64) bool {
		keys = append(keys, k)
		values = append(values, v)
		return true
	})

	if len(keys) != 3 || len(values) != 3 {
		t.Errorf("Range failed: %v, %v", keys, values)
	}
	if !sliceContains(keys, "foo") || !sliceContains(keys, "bar") || !sliceContains(keys, "baz") {
		t.Errorf("Range failed: %v", keys)
	}
	if !sliceContains(values, 1) || !sliceContains(values, 2) || !sliceContains(values, 3) {
		t.Errorf("Range failed: %v", values)
	}
	// 测试 Delete 方法
	m.Delete("foo")
	if _, ok := m.Load("foo"); ok {
		t.Errorf("Delete failed")
	}
}

func containsValue(slice interface{}, item interface{}) bool {
	switch s := slice.(type) {
	case []string:
		for _, v := range s {
			if v == item.(string) {
				return true
			}
		}
	case []int:
		for _, v := range s {
			if v == item.(int) {
				return true
			}
		}
	}
	return false
}

func sliceContains[V comparable](slice []V, value V) bool {
	for _, v := range slice {
		if v == value {
			return true
		}
	}
	return false
}