Function TestDoubleFreeTurnSimple

internal/pool/double_freeturn_simple_test.go:27–157

TestDoubleFreeTurnSimple tests the double-free bug with a simple scenario. This test FAILS with the OLD code and PASSES with the NEW code. Scenario: 1. Request A times out, Dial A completes and delivers connection to Request B 2. Request B's own Dial B completes later 3. With the bug: Dial B frees

(t *testing.T)

// - With the bug: All succeed (pool size violated)
// - With the fix: Only PoolSize succeed
func TestDoubleFreeTurnSimple(t *testing.T) {
	ctx := context.Background()

	var dialCount atomic.Int32
	dialBComplete := make(chan struct{})
	requestBGotConn := make(chan struct{})
	requestBCalledPut := make(chan struct{})

	controlledDialer := func(ctx context.Context) (net.Conn, error) {
		count := dialCount.Add(1)

		if count == 1 {
			// Dial A: takes 150ms
			time.Sleep(150 * time.Millisecond)
			t.Logf("Dial A completed")
		} else if count == 2 {
			// Dial B: takes 300ms (longer than Dial A)
			time.Sleep(300 * time.Millisecond)
			t.Logf("Dial B completed")
			close(dialBComplete)
		} else {
			// Other dials: fast
			time.Sleep(10 * time.Millisecond)
		}

		return newDummyConn(), nil
	}

	testPool := pool.NewConnPool(&pool.Options{
		Dialer:             controlledDialer,
		PoolSize:           2, // Only 2 concurrent operations allowed
		MaxConcurrentDials: 5,
		DialTimeout:        1 * time.Second,
		PoolTimeout:        1 * time.Second,
	})
	defer testPool.Close()

	// Request A: Short timeout (100ms), will timeout before dial completes (150ms)
	go func() {
		shortCtx, cancel := context.WithTimeout(ctx, 100*time.Millisecond)
		defer cancel()

		_, err := testPool.Get(shortCtx)
		if err != nil {
			t.Logf("Request A: Timed out as expected: %v", err)
		}
	}()

	// Wait for Request A to start
	time.Sleep(20 * time.Millisecond)

	// Request B: Long timeout, will receive connection from Request A's dial
	requestBDone := make(chan struct{})
	go func() {
		defer close(requestBDone)

		longCtx, cancel := context.WithTimeout(ctx, 1*time.Second)
		defer cancel()