246 lines
6.6 KiB
Go
246 lines
6.6 KiB
Go
package dirty
|
|
|
|
import (
|
|
"sync"
|
|
"testing"
|
|
|
|
"gotest.tools/v3/assert"
|
|
)
|
|
|
|
// testValue is a simple cloneable type for testing
|
|
type testValue struct {
|
|
data string
|
|
}
|
|
|
|
func (v *testValue) Clone() *testValue {
|
|
return &testValue{data: v.data}
|
|
}
|
|
|
|
func TestSyncMapProxyFor(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
t.Run("proxy for race condition", func(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
// Create a sync map with a base value
|
|
base := map[string]*testValue{
|
|
"key1": {data: "original"},
|
|
}
|
|
syncMap := NewSyncMap(base, nil)
|
|
|
|
// Load the same entry from multiple goroutines to simulate race condition
|
|
var entry1, entry2 *SyncMapEntry[string, *testValue]
|
|
var wg sync.WaitGroup
|
|
wg.Add(2)
|
|
|
|
// First goroutine loads the entry
|
|
go func() {
|
|
defer wg.Done()
|
|
var ok bool
|
|
entry1, ok = syncMap.Load("key1")
|
|
assert.Assert(t, ok, "entry1 should be loaded")
|
|
}()
|
|
|
|
// Second goroutine loads the same entry
|
|
go func() {
|
|
defer wg.Done()
|
|
var ok bool
|
|
entry2, ok = syncMap.Load("key1")
|
|
assert.Assert(t, ok, "entry2 should be loaded")
|
|
}()
|
|
|
|
wg.Wait()
|
|
|
|
// Both entries should exist and have the same initial value
|
|
assert.Equal(t, "original", entry1.Value().data)
|
|
assert.Equal(t, "original", entry2.Value().data)
|
|
assert.Equal(t, false, entry1.Dirty())
|
|
assert.Equal(t, false, entry2.Dirty())
|
|
|
|
// Now try to change both entries concurrently to trigger the proxy mechanism.
|
|
// (This change doesn't actually have to be concurrent to test the proxy behavior,
|
|
// but might exercise concurrency safety in -race mode.)
|
|
var changeWg sync.WaitGroup
|
|
changeWg.Add(2)
|
|
|
|
go func() {
|
|
defer changeWg.Done()
|
|
entry1.Change(func(v *testValue) {
|
|
v.data = "changed_by_entry1"
|
|
})
|
|
}()
|
|
|
|
go func() {
|
|
defer changeWg.Done()
|
|
entry2.Change(func(v *testValue) {
|
|
v.data = "changed_by_entry2"
|
|
})
|
|
}()
|
|
|
|
changeWg.Wait()
|
|
|
|
// After the race, one entry should have proxyFor set and both should reflect the same final state
|
|
// The exact final value depends on which goroutine wins the race, but both entries should be consistent
|
|
finalValue1 := entry1.Value().data
|
|
finalValue2 := entry2.Value().data
|
|
assert.Equal(t, finalValue1, finalValue2, "both entries should have the same final value")
|
|
|
|
// Both entries should be marked as dirty
|
|
assert.Equal(t, true, entry1.Dirty())
|
|
assert.Equal(t, true, entry2.Dirty())
|
|
|
|
// At least one entry should have proxyFor set (the one that lost the race)
|
|
hasProxy := (entry1.proxyFor != nil) || (entry2.proxyFor != nil)
|
|
assert.Assert(t, hasProxy, "at least one entry should have proxyFor set")
|
|
|
|
// If entry1 has a proxy, it should point to entry2, and vice versa
|
|
if entry1.proxyFor != nil {
|
|
assert.Equal(t, entry2, entry1.proxyFor, "entry1 should proxy to entry2")
|
|
}
|
|
if entry2.proxyFor != nil {
|
|
assert.Equal(t, entry1, entry2.proxyFor, "entry2 should proxy to entry1")
|
|
}
|
|
})
|
|
|
|
t.Run("proxy operations delegation", func(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
base := map[string]*testValue{
|
|
"key1": {data: "original"},
|
|
}
|
|
syncMap := NewSyncMap(base, nil)
|
|
|
|
// Load two entries for the same key
|
|
entry1, ok1 := syncMap.Load("key1")
|
|
assert.Assert(t, ok1)
|
|
entry2, ok2 := syncMap.Load("key1")
|
|
assert.Assert(t, ok2)
|
|
|
|
// Force one to become a proxy by making them both dirty in sequence
|
|
entry1.Change(func(v *testValue) {
|
|
v.data = "changed_by_entry1"
|
|
})
|
|
entry2.Change(func(v *testValue) {
|
|
v.data = "changed_by_entry2"
|
|
})
|
|
|
|
// Determine which is the proxy and which is the target
|
|
var proxy, target *SyncMapEntry[string, *testValue]
|
|
if entry1.proxyFor != nil {
|
|
proxy = entry1
|
|
target = entry2
|
|
} else {
|
|
proxy = entry2
|
|
target = entry1
|
|
}
|
|
|
|
// Test that proxy operations are delegated to the target
|
|
// Change through proxy should affect target
|
|
proxy.Change(func(v *testValue) {
|
|
v.data = "changed_through_proxy"
|
|
})
|
|
assert.Equal(t, "changed_through_proxy", target.Value().data)
|
|
assert.Equal(t, "changed_through_proxy", proxy.Value().data)
|
|
|
|
// ChangeIf through proxy should work
|
|
changed := proxy.ChangeIf(
|
|
func(v *testValue) bool { return v.data == "changed_through_proxy" },
|
|
func(v *testValue) { v.data = "conditional_change" },
|
|
)
|
|
assert.Assert(t, changed)
|
|
assert.Equal(t, "conditional_change", target.Value().data)
|
|
assert.Equal(t, "conditional_change", proxy.Value().data)
|
|
|
|
// Dirty status should be consistent
|
|
assert.Equal(t, target.Dirty(), proxy.Dirty())
|
|
|
|
// Locked operations should work through proxy
|
|
proxy.Locked(func(v Value[*testValue]) {
|
|
v.Change(func(val *testValue) {
|
|
val.data = "locked_change"
|
|
})
|
|
})
|
|
assert.Equal(t, "locked_change", target.Value().data)
|
|
assert.Equal(t, "locked_change", proxy.Value().data)
|
|
})
|
|
|
|
t.Run("proxy delete operations", func(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
base := map[string]*testValue{
|
|
"key1": {data: "original"},
|
|
}
|
|
syncMap := NewSyncMap(base, nil)
|
|
|
|
// Load two entries and make one a proxy
|
|
entry1, _ := syncMap.Load("key1")
|
|
entry2, _ := syncMap.Load("key1")
|
|
|
|
entry1.Change(func(v *testValue) { v.data = "modified" })
|
|
entry2.Change(func(v *testValue) { v.data = "modified2" })
|
|
|
|
// Determine which is the proxy
|
|
var proxy *SyncMapEntry[string, *testValue]
|
|
if entry1.proxyFor != nil {
|
|
proxy = entry1
|
|
} else {
|
|
proxy = entry2
|
|
}
|
|
|
|
// Delete through proxy should affect target
|
|
proxy.Delete()
|
|
|
|
// Both should reflect the deletion
|
|
_, exists := syncMap.Load("key1")
|
|
assert.Equal(t, false, exists, "key should be deleted from sync map")
|
|
|
|
// DeleteIf through proxy should work
|
|
base2 := map[string]*testValue{
|
|
"key2": {data: "test"},
|
|
}
|
|
syncMap2 := NewSyncMap(base2, nil)
|
|
|
|
entry3, _ := syncMap2.Load("key2")
|
|
entry4, _ := syncMap2.Load("key2")
|
|
|
|
entry3.Change(func(v *testValue) { v.data = "modified" })
|
|
entry4.Change(func(v *testValue) { v.data = "modified2" })
|
|
|
|
var proxy2 *SyncMapEntry[string, *testValue]
|
|
if entry3.proxyFor != nil {
|
|
proxy2 = entry3
|
|
} else {
|
|
proxy2 = entry4
|
|
}
|
|
|
|
proxy2.DeleteIf(func(v *testValue) bool {
|
|
return v.data == "modified2" || v.data == "modified"
|
|
})
|
|
|
|
_, exists2 := syncMap2.Load("key2")
|
|
assert.Equal(t, false, exists2, "key2 should be deleted conditionally")
|
|
})
|
|
|
|
t.Run("no proxy when no race", func(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
base := map[string]*testValue{
|
|
"key1": {data: "original"},
|
|
}
|
|
syncMap := NewSyncMap(base, nil)
|
|
|
|
// Load and modify a single entry - no race condition
|
|
entry, ok := syncMap.Load("key1")
|
|
assert.Assert(t, ok)
|
|
|
|
entry.Change(func(v *testValue) {
|
|
v.data = "changed"
|
|
})
|
|
|
|
// Should not have a proxy since there was no race
|
|
assert.Assert(t, entry.proxyFor == nil, "entry should not have proxyFor when no race occurs")
|
|
assert.Equal(t, true, entry.Dirty())
|
|
assert.Equal(t, "changed", entry.Value().data)
|
|
})
|
|
}
|