testing/synctest support for Go 1.25+

Author: flyingmutant

engine.go

@@ -480,6 +480,10 @@ func panicToError(p any, skip int) *testError {
 		return nil
 	}
 
+	if err, ok := p.(*testError); ok {
+		return err
+	}
+
 	callers := make([]uintptr, tracebackLen)
 	callers = callers[:runtime.Callers(skip, callers)]
 	frames := runtime.CallersFrames(callers)

go.mod

@@ -1,3 +1,3 @@
 module pgregory.net/rapid
 
-go 1.18
+go 1.23

synctest_common.go

@@ -0,0 +1,28 @@
+package rapid
+
+import "testing"
+
+// underlyingTestingT returns the *testing.T associated with tb, if any.
+func underlyingTestingT(tbValue TB) (*testing.T, bool) {
+	if tbValue == nil {
+		return nil, false
+	}
+	return underlyingTestingTPrivate(tb(tbValue))
+}
+
+func underlyingTestingTPrivate(tb tb) (*testing.T, bool) {
+	// Some rapid helpers clone the TB they receive by wrapping it in a new *rapid.T.
+	// This happens, for example, when Custom generators spin up helper *T instances.
+	// When SyncTest needs the underlying *testing.T we peel through any number of *rapid.T
+	// layers until we reach the real testing object.
+	switch t := any(tb).(type) {
+	case *testing.T:
+		return t, true
+	case *T:
+		return underlyingTestingTPrivate(t.tb)
+	case nilTB:
+		return nil, false
+	default:
+		return nil, false
+	}
+}

synctest_disabled.go

@@ -0,0 +1,12 @@
+//go:build !go1.25
+
+package rapid
+
+// SyncTest is only available on Go 1.25+.
+func SyncTest(t *T, _ func(*T)) {
+	if t == nil {
+		panic("rapid.SyncTest requires *rapid.T")
+	}
+	t.Helper()
+	t.Fatalf("[rapid] SyncTest requires Go 1.25 or newer")
+}

synctest_enabled.go

@@ -0,0 +1,104 @@
+//go:build go1.25
+
+package rapid
+
+import (
+	"testing"
+	"testing/synctest"
+)
+
+// SyncTest runs prop within a testing/synctest bubble.
+// Callers must already be executing inside a rapid.Check-style helper;
+// SyncTest forwards failures to the parent *rapid.T and restores its state afterwards.
+func SyncTest(t *T, prop func(*T)) {
+	if t == nil {
+		panic("rapid.SyncTest requires *rapid.T")
+	}
+
+	t.Helper()
+
+	testT, ok := underlyingTestingT(t.tb)
+	if !ok {
+		t.Fatalf("[rapid] SyncTest requires a *testing.T backing the current rapid test")
+		return
+	}
+
+	syncTestWithinRapid(t, testT, prop)
+}
+
+func syncTestWithinRapid(t *T, parent *testing.T, prop func(*T)) {
+	// synctest.Test converts failures inside the bubble into parent.FailNow (runtime.Goexit),
+	// which would bypass rapid's panic-based failure capture/shrinking. Run the bubble in a
+	// separate goroutine, swallow failures inside the bubble, and re-panic outside as a
+	// *testError so checkOnce can shrink and generate failfiles as usual.
+	resultCh := make(chan *testError, 1)
+
+	go func() {
+		var captured *testError
+		returned := false
+		defer func() {
+			if r := recover(); r != nil {
+				captured = panicToError(r, 3)
+			} else if !returned && captured == nil {
+				captured = panicToError(stopTest("[rapid] SyncTest aborted via testing.FailNow"), 3)
+			}
+			resultCh <- captured
+		}()
+
+		synctest.Test(parent, func(st *testing.T) {
+			st.Helper()
+
+			prevTB := t.tb
+			prevTBLog := t.tbLog // preserved so we keep the original logging behaviour
+			prevCtx := t.ctx
+			prevCancel := t.cancelCtx
+			prevCleanups := t.cleanups
+			prevCleaning := t.cleaning.Load()
+
+			t.tb = st
+			// Reset per-run state before the property runs in the bubble.
+			// No lock is needed because no other goroutine touches t before we hand control to prop.
+			t.ctx = nil
+			t.cancelCtx = nil
+			t.cleanups = nil
+			t.cleaning.Store(false)
+
+			var panicValue any
+			defer func() {
+				if r := recover(); r != nil {
+					panicValue = r
+				}
+
+				func() {
+					// Always run rapid cleanups, even if the property panicked.
+					defer func() {
+						if r := recover(); r != nil {
+							panicValue = r
+						}
+					}()
+					t.cleanup()
+				}()
+
+				t.tb = prevTB
+				t.tbLog = prevTBLog
+				t.ctx = prevCtx
+				t.cancelCtx = prevCancel
+				t.cleanups = prevCleanups
+				t.cleaning.Store(prevCleaning)
+
+				if panicValue != nil {
+					captured = panicToError(panicValue, 3)
+				}
+			}()
+
+			prop(t)
+			t.failOnError()
+		})
+
+		returned = true
+	}()
+
+	if err := <-resultCh; err != nil {
+		panic(err)
+	}
+}

synctest_enabled_internal_test.go

@@ -0,0 +1,31 @@
+//go:build go1.25
+
+package rapid
+
+import (
+	"strings"
+	"testing"
+)
+
+func TestSyncTest_FailureIsCapturedForShrinking(t *testing.T) {
+	rt := newT(tb(t), newRandomBitStream(1, true), false, nil)
+
+	err := checkOnce(rt, func(t *T) {
+		SyncTest(t, func(inner *T) {
+			inner.Fatalf("boom")
+		})
+	})
+
+	if err == nil {
+		t.Fatalf("checkOnce did not report failure from SyncTest")
+	}
+	if !err.isStopTest() {
+		t.Fatalf("expected stopTest failure, got %T (%v)", err.data, err)
+	}
+	if !strings.Contains(errorString(err), "boom") {
+		t.Fatalf("missing failure message: %q", errorString(err))
+	}
+	if !strings.Contains(traceback(err), "synctest_enabled_internal_test.go") {
+		t.Fatalf("traceback does not include property call site:\n%v", traceback(err))
+	}
+}

synctest_enabled_test.go

@@ -0,0 +1,44 @@
+//go:build go1.25
+
+package rapid_test
+
+import (
+	"sync/atomic"
+	"testing"
+	"testing/synctest"
+	"time"
+
+	"pgregory.net/rapid"
+)
+
+func TestSyncTest(t *testing.T) {
+	rapid.Check(t, func(rt *rapid.T) {
+		var cleaned atomic.Bool
+
+		rapid.SyncTest(rt, func(inner *rapid.T) {
+			inner.Cleanup(func() {
+				cleaned.Store(true)
+			})
+
+			const sleep = 2 * time.Second
+			start := time.Now()
+			time.Sleep(sleep)
+			if got := time.Since(start); got != sleep {
+				inner.Fatalf("virtual time advanced by %v, want %v", got, sleep)
+			}
+
+			done := make(chan struct{})
+			go func() { close(done) }()
+			synctest.Wait()
+			select {
+			case <-done:
+			default:
+				inner.Fatalf("goroutine did not finish inside synctest bubble")
+			}
+		})
+
+		if !cleaned.Load() {
+			rt.Fatalf("cleanup registered inside SyncTest did not run")
+		}
+	})
+}