Function TestThreadSafeCache

challenge-28/solution-template_test.go:252–316

TestThreadSafeCache tests the thread-safe wrapper

(t *testing.T)

// TestThreadSafeCache tests the thread-safe wrapper
func TestThreadSafeCache(t *testing.T) {
	t.Run("Concurrent Access", func(t *testing.T) {
		baseCache := NewLRUCache(100)
		cache := NewThreadSafeCache(baseCache)
		if cache == nil {
			t.Fatal("NewThreadSafeCache returned nil")
		}

		const numGoroutines = 10
		const numOperations = 100

		var wg sync.WaitGroup
		for i := 0; i < numGoroutines; i++ {
			wg.Add(1)
			go func(id int) {
				defer wg.Done()
				for j := 0; j < numOperations; j++ {
					key := fmt.Sprintf("key-%d-%d", id, j)
					cache.Put(key, j)
					cache.Get(key)
					if j%10 == 0 {
						cache.Delete(key)
					}
				}
			}(i)
		}

		wg.Wait()

		// Should not panic and should have some items
		if cache.Size() < 0 {
			t.Error("Cache size should not be negative after concurrent operations")
		}
	})

	t.Run("Interface Compatibility", func(t *testing.T) {
		baseCache := NewLRUCache(2)
		cache := NewThreadSafeCache(baseCache)

		// Test that all methods work through the interface
		cache.Put("a", 1)
		value, found := cache.Get("a")
		if !found || value != 1 {
			t.Errorf("Expected (1, true), got (%v, %v)", value, found)
		}

		if cache.Size() != 1 {
			t.Errorf("Expected size 1, got %d", cache.Size())
		}

		if cache.Capacity() != 2 {
			t.Errorf("Expected capacity 2, got %d", cache.Capacity())
		}

		deleted := cache.Delete("a")
		if !deleted {
			t.Error("Expected Delete to return true")
		}