futex_test.go

package futex_test

import (
	"testing"
	"time"

	"github.com/hexon/futex"
)

// Tests are generated by AI. Sorry.

func TestWaitAndWake_Single(t *testing.T) {
	var uaddr uint32 = 0

	done := make(chan struct{})

	go func() {
		err := futex.Wait(&uaddr, 0, 0, -1)
		if err != nil {
			t.Errorf("Wait failed: %v", err)
		}
		close(done)
	}()

	// Give goroutine time to block
	time.Sleep(10 * time.Millisecond)

	n, err := futex.Wake(&uaddr, 0, 1)
	if err != nil {
		t.Fatalf("Wake failed: %v", err)
	}
	if n != 1 {
		t.Fatalf("expected 1 waiter woken, got %d", n)
	}

	select {
	case <-done:
	case <-time.After(time.Second):
		t.Fatal("waiter was not woken")
	}
}

func TestWait_Timeout(t *testing.T) {
	var uaddr uint32 = 0

	start := time.Now()
	err := futex.Wait(&uaddr, 0, 0, 50*time.Millisecond)

	if err == nil {
		t.Fatal("expected timeout error, got nil")
	}

	if time.Since(start) < 40*time.Millisecond {
		t.Fatal("Wait returned too early")
	}
}

func TestWait_ValueMismatch(t *testing.T) {
	var uaddr uint32 = 1 // does NOT match expected 0

	start := time.Now()
	err := futex.Wait(&uaddr, 0, 0, time.Second)

	if err == nil {
		t.Fatal("expected error due to value mismatch")
	}

	if time.Since(start) > 50*time.Millisecond {
		t.Fatal("Wait blocked but should not have")
	}
}

func TestRequeue_Basic(t *testing.T) {
	var uaddr1 uint32 = 0
	var uaddr2 uint32 = 0

	const waiters = 4

	done := make(chan struct{}, waiters)

	// Start waiters on uaddr1
	for i := 0; i < waiters; i++ {
		go func() {
			_ = futex.Wait(&uaddr1, 0, 0, -1)
			done <- struct{}{}
		}()
	}

	time.Sleep(100 * time.Millisecond)

	// Wake 1, requeue the rest to uaddr2
	n, err := futex.Requeue(&uaddr1, 0, 1, waiters-1, &uaddr2)
	if err != nil {
		t.Fatalf("Requeue failed: %v", err)
	}

	if n != waiters {
		t.Fatalf("expected %d affected, got %d", waiters, n)
	}

	// Exactly 1 should wake immediately
	select {
	case <-done:
	case <-time.After(time.Second):
		t.Fatal("expected one waiter to wake immediately")
	}

	// Others should NOT wake yet
	select {
	case <-done:
		t.Fatal("more than one waiter woke prematurely")
	case <-time.After(100 * time.Millisecond):
	}

	// Now wake requeued waiters via uaddr2
	n2, err := futex.Wake(&uaddr2, 0, waiters)
	if err != nil {
		t.Fatalf("Wake on uaddr2 failed: %v", err)
	}

	if n2 != waiters-1 {
		t.Errorf("expected to wake %d requeued, got %d", waiters-1, n2)
	}

	// All remaining should now complete
	for i := 0; i < waiters-1; i++ {
		select {
		case <-done:
		case <-time.After(time.Second):
			t.Error("requeued waiter did not wake")
		}
	}
}

func TestCmpRequeue_Success(t *testing.T) {
	var uaddr1 uint32 = 42
	var uaddr2 uint32 = 0

	const waiters = 3
	done := make(chan struct{}, waiters)

	for i := 0; i < waiters; i++ {
		go func() {
			_ = futex.Wait(&uaddr1, 0, 42, -1)
			done <- struct{}{}
		}()
	}

	time.Sleep(100 * time.Millisecond)

	n, err := futex.CmpRequeue(&uaddr1, 0, 1, waiters-1, &uaddr2, 42)
	if err != nil {
		t.Fatalf("CmpRequeue failed: %v", err)
	}

	if n != waiters {
		t.Fatalf("expected %d affected, got %d", waiters, n)
	}

	// One wakes immediately
	select {
	case <-done:
	case <-time.After(time.Second):
		t.Fatal("expected one immediate wake")
	}

	// Wake remaining via uaddr2
	_, _ = futex.Wake(&uaddr2, 0, waiters)

	for i := 0; i < waiters-1; i++ {
		select {
		case <-done:
		case <-time.After(time.Second):
			t.Error("requeued waiter not woken")
		}
	}
}

func TestCmpRequeue_CompareFail(t *testing.T) {
	var uaddr1 uint32 = 1
	var uaddr2 uint32 = 0

	done := make(chan struct{})

	go func() {
		_ = futex.Wait(&uaddr1, 0, 1, -1)
		close(done)
	}()

	time.Sleep(100 * time.Millisecond)

	// cmpVal does NOT match
	_, err := futex.CmpRequeue(&uaddr1, 0, 1, 1, &uaddr2, 999)

	if err == nil {
		t.Fatal("expected error due to compare mismatch")
	}

	// Waiter should still be blocked
	select {
	case <-done:
		t.Fatal("waiter woke unexpectedly")
	case <-time.After(50 * time.Millisecond):
	}

	// Clean up
	_, _ = futex.Wake(&uaddr1, 0, 1)

	select {
	case <-done:
	case <-time.After(time.Second):
		t.Fatal("waiter did not wake during cleanup")
	}
}