Initial commit.

keyedmutex_test.go

@@ -1,81 +1,92 @@
 package keyedmutex
 
-
 import (
 	"sync"
 	"testing"
-	"time"
 )
 
-func TestKeyedMutex(t *testing.T) {
-	checkState := func(t *testing.T, m KeyedMutex[string], keys ...string) {
-		if len(m.waitList) != len(keys) {
-			t.Fatal(m.waitList, keys)
-		}
-
-		for _, key := range keys {
-			if _, ok := m.waitList[key]; !ok {
-				t.Fatal(key)
-			}
-		}
-	}
-
+func TestLock_CleansUpMap(t *testing.T) {
 	m := New[string]()
-	checkState(t, m)
-
 	m.Lock("a")
-	checkState(t, m, "a")
-	m.Lock("b")
-	checkState(t, m, "a", "b")
-	m.Lock("c")
-	checkState(t, m, "a", "b", "c")
-
-	if m.TryLock("a") {
-		t.Fatal("a")
-	}
-	if m.TryLock("b") {
-		t.Fatal("b")
-	}
-	if m.TryLock("c") {
-		t.Fatal("c")
-	}
-
-	if !m.TryLock("d") {
-		t.Fatal("d")
-	}
-
-	checkState(t, m, "a", "b", "c", "d")
-
-	if !m.TryLock("e") {
-		t.Fatal("e")
-	}
-	checkState(t, m, "a", "b", "c", "d", "e")
-
-	m.Unlock("c")
-	checkState(t, m, "a", "b", "d", "e")
 	m.Unlock("a")
-	checkState(t, m, "b", "d", "e")
-	m.Unlock("e")
-	checkState(t, m, "b", "d")
+	if len(m.byKey) != 0 {
+		t.Fatalf("expected empty byKey, got %v", m.byKey)
+	}
+}
 
-	wg := sync.WaitGroup{}
-	for i := 0; i < 8; i++ {
+func TestTryLock_SucceedsOnFreeKey(t *testing.T) {
+	m := New[string]()
+	if !m.TryLock("a") {
+		t.Fatal("expected TryLock to succeed on free key")
+	}
+	m.Unlock("a")
+}
+
+func TestTryLock_FailsOnLockedKey(t *testing.T) {
+	m := New[string]()
+	m.Lock("a")
+	if m.TryLock("a") {
+		t.Fatal("expected TryLock to fail on locked key")
+	}
+	m.Unlock("a")
+}
+
+func TestTryLock_FailureDoesNotCorruptLock(t *testing.T) {
+	// A failed TryLock must not call Unlock on the key's mutex.
+	// The old bug did this unconditionally, so the Unlock below would
+	// double-unlock and panic.
+	m := New[string]()
+	m.Lock("a")
+	m.TryLock("a") // must return false and leave the lock intact
+	m.Unlock("a")  // must not panic
+}
+
+func TestTryLock_FailureDecrementsCount(t *testing.T) {
+	// A failed TryLock must undo its getLock increment so that the
+	// original holder's Unlock cleans up the map entry.
+	m := New[string]()
+	m.Lock("a")
+	m.TryLock("a") // fails; a leaked count would leave a stale map entry
+	m.Unlock("a")
+	if len(m.byKey) != 0 {
+		t.Fatalf("expected empty byKey after unlock, got %v", m.byKey)
+	}
+}
+
+func TestMultipleKeys_AreIndependent(t *testing.T) {
+	m := New[string]()
+	m.Lock("a")
+	if !m.TryLock("b") {
+		t.Fatal("expected TryLock on different key to succeed while 'a' is locked")
+	}
+	m.Unlock("b")
+	m.Unlock("a")
+}
+
+func TestConcurrentLock_MutualExclusion(t *testing.T) {
+	m := New[string]()
+	const N = 100
+	var wg sync.WaitGroup
+	var shared int // intentionally non-atomic: race detector catches improper access
+
+	for range N {
 		wg.Add(1)
 		go func() {
 			defer wg.Done()
-			m.Lock("b")
-			m.Unlock("b")
+			m.Lock("a")
+			shared++
+			m.Unlock("a")
 		}()
 	}
 
-	time.Sleep(100 * time.Millisecond)
-	m.Unlock("b")
 	wg.Wait()
 
-	checkState(t, m, "d")
-
-	m.Unlock("d")
-	checkState(t, m)
+	if shared != N {
+		t.Fatalf("expected %d, got %d", N, shared)
+	}
+	if len(m.byKey) != 0 {
+		t.Fatalf("expected empty byKey after all goroutines done, got %v", m.byKey)
+	}
 }
 
 func TestKeyedMutex_unlockUnlocked(t *testing.T) {
@@ -93,31 +104,8 @@ func BenchmarkUncontendedMutex(b *testing.B) {
 	m := New[string]()
 	key := "xyz"
 
-	for i := 0; i < b.N; i++ {
+	for b.Loop() {
 		m.Lock(key)
 		m.Unlock(key)
 	}
 }
-
-func BenchmarkContendedMutex(b *testing.B) {
-	m := New[string]()
-	key := "xyz"
-
-	m.Lock(key)
-
-	wg := sync.WaitGroup{}
-	for i := 0; i < b.N; i++ {
-		wg.Add(1)
-		go func() {
-			defer wg.Done()
-			m.Lock(key)
-			m.Unlock(key)
-		}()
-	}
-
-	time.Sleep(time.Second)
-
-	b.ResetTimer()
-	m.Unlock(key)
-	wg.Wait()
-}