Function TestConnStateMachine_FIFOWithFastPath

internal/pool/conn_state_test.go:464–529

(t *testing.T)

}

func TestConnStateMachine_FIFOWithFastPath(t *testing.T) {
	sm := NewConnStateMachine()
	sm.Transition(StateIdle) // Start in READY so fast path is available

	const numGoroutines = 10
	var executionOrder []int
	var orderMu sync.Mutex
	var wg sync.WaitGroup
	var startBarrier sync.WaitGroup
	startBarrier.Add(numGoroutines)

	// Launch goroutines that will all try the fast path
	for i := 0; i < numGoroutines; i++ {
		wg.Add(1)
		go func(id int) {
			defer wg.Done()

			// Wait for all goroutines to be ready
			startBarrier.Done()
			startBarrier.Wait()

			// Small stagger to establish arrival order
			time.Sleep(time.Duration(id) * 100 * time.Microsecond)

			ctx := context.Background()

			// This might use fast path (CAS) or slow path (queue)
			_, err := sm.AwaitAndTransition(ctx, []ConnState{StateIdle}, StateInitializing)
			if err != nil {
				t.Errorf("Goroutine %d: failed to transition: %v", id, err)
				return
			}

			// Record execution order
			orderMu.Lock()
			executionOrder = append(executionOrder, id)
			orderMu.Unlock()

			t.Logf("Goroutine %d: executed (position %d)", id, len(executionOrder))

			// Simulate work
			time.Sleep(5 * time.Millisecond)

			// Transition back to READY to allow next waiter
			sm.Transition(StateIdle)
		}(i)
	}

	wg.Wait()

	t.Logf("Execution order: %v", executionOrder)

	// Check if FIFO was maintained
	// With the current fast-path implementation, this might NOT be FIFO
	fifoViolations := 0
	for i := 0; i < numGoroutines; i++ {
		if executionOrder[i] != i {
			fifoViolations++