feat: add support for benchmarks (#144)

Signed-off-by: Tronje Krop <tronje.krop@jactors.de>

Author: tkrop

README.md

@@ -281,3 +281,11 @@ project has more than 25 Stars, I will introduce semantic versions `v1`.
 If you like to contribute, please create an issue and/or pull request with a
 proper description of your proposal or contribution. I will review it and
 provide feedback on it as fast as possible.
+
+
+## Disclaimer
+
+This software is `100%` written by humans. AI is only used to review code,
+search for bugs, improve test coverage, and analyse performance issues. All
+actions executed with the help of AI are carefully reviewed, checked, and
+modified with the human standards and quality goals in mind.

reflect/reflect.go

@@ -306,3 +306,40 @@ func Name[P any](name string, param P) string {
 	}
 	return ""
 }
+
+// Run executes a test with given name and test callback function on the given
+// target. The target is typically a test runner instance, such as `*testing.T`
+// or `*testing.B` and must implement `Run(name string, call func(T))` that is
+// called to execute the test.
+//
+// A panic is raised if the target has no `Run` method or if target type does
+// not implement T.
+func Run[T any](target any, name string, call func(T)) {
+	value := reflect.ValueOf(target)
+	if !value.IsValid() {
+		panic("target must not be nil")
+	}
+
+	method := value.MethodByName("Run")
+	if !method.IsValid() {
+		panic("target does not implement method [" +
+			reflect.TypeOf(target).String() + " => Run]")
+	}
+
+	// Build a typed func(*concreteT) that wraps the inner argument as T
+	// before forwarding to the provided call function.
+	wrapper := reflect.MakeFunc(method.Type().In(1),
+		func(args []reflect.Value) []reflect.Value {
+			iface := args[0].Interface()
+			if typ, ok := iface.(T); ok {
+				call(typ)
+				return nil
+			}
+
+			panic("type does not implement [" +
+				reflect.TypeOf(iface).String() + " => " +
+				reflect.TypeOf((*T)(nil)).Elem().String() + "]")
+		})
+
+	method.Call([]reflect.Value{reflect.ValueOf(name), wrapper})
+}

reflect/reflect_test.go

@@ -1154,3 +1154,83 @@ func TestName(t *testing.T) {
 			assert.Equal(t, param.expect, result)
 		})
 }
+
+// runner is a test double whose Run method delivers itself to the callback.
+type runner struct {
+	called bool
+}
+
+func (r *runner) Run(_ string, call func(*runner)) bool {
+	call(r)
+
+	return true
+}
+
+// wrongRunner has a Run method that delivers a wrongRunner value. Since
+// wrongRunner does not implement *runner, the type assertion in Run fails.
+type wrongRunner struct{}
+
+func (wrongRunner) Run(_ string, f func(wrongRunner)) bool {
+	f(wrongRunner{})
+
+	return true
+}
+
+// RunParams holds the parameters for TestRun.
+type RunParams struct {
+	target any
+	name   string
+	expect mock.SetupFunc
+	check  func(test.Test, *runner)
+}
+
+var runTestCases = map[string]RunParams{
+	// Happy path.
+	"run": {
+		target: &runner{},
+		name:   "sub",
+		check: func(t test.Test, r *runner) {
+			assert.True(t, r.called)
+		},
+	},
+
+	// Error paths.
+	"nil-target": {
+		name:   "sub",
+		expect: test.Panic("target must not be nil"),
+	},
+
+	"no-run-method": {
+		target: struct{}{},
+		name:   "sub",
+		expect: test.Panic("target does not implement method " +
+			"[struct {} => Run]"),
+	},
+
+	"inner-no-implement": {
+		target: wrongRunner{},
+		name:   "sub",
+		expect: test.Panic(
+			"type does not implement " +
+				"[reflect_test.wrongRunner => *reflect_test.runner]"),
+	},
+}
+
+func TestRun(t *testing.T) {
+	test.Map(t, runTestCases).
+		Run(func(t test.Test, param RunParams) {
+			// Given
+			mock.NewMocks(t).Expect(param.expect)
+			r, _ := param.target.(*runner)
+
+			// When
+			reflect.Run[*runner](param.target, param.name, func(inner *runner) {
+				inner.called = true
+			})
+
+			// Then
+			if param.check != nil {
+				param.check(t, r)
+			}
+		})
+}

test/runner.go

@@ -7,7 +7,6 @@ import (
 	"runtime"
 	"strconv"
 	"strings"
-	"testing"
 	"time"
 
 	"github.com/tkrop/go-testing/internal/maps"
@@ -130,7 +129,7 @@ type Factory[P any] interface {
 // factory is a generic parameterized test factory struct.
 type factory[P any] struct {
 	// The testing context to run the tests in.
-	t *testing.T
+	t Test
 	// A wait group to synchronize the test execution.
 	wg sync.WaitGroup
 	// The test parameter sets to run.
@@ -148,7 +147,7 @@ type factory[P any] struct {
 // can be a single test parameter set, a slice of test parameter sets, or a map
 // of named test parameter sets. The test runner is looking into the parameter
 // set to determine a suitable test case name, e.g. by using a `name` parameter.
-func Any[P any](t *testing.T, params any) Factory[P] {
+func Any[P any](t Test, params any) Factory[P] {
 	t.Helper()
 
 	return &factory[P]{
@@ -161,7 +160,7 @@ func Any[P any](t *testing.T, params any) Factory[P] {
 // Param creates a new parallel test runner with given test parameter sets
 // provided as variadic arguments. The test runner is looking into the
 // parameter set to find a suitable test case name.
-func Param[P any](t *testing.T, params ...P) Factory[P] {
+func Param[P any](t Test, params ...P) Factory[P] {
 	t.Helper()
 
 	if len(params) == 1 {
@@ -172,7 +171,7 @@ func Param[P any](t *testing.T, params ...P) Factory[P] {
 
 // Map creates a new parallel test runner with given test parameter sets
 // provided as a test case name to parameter sets mapping.
-func Map[P any](t *testing.T, params ...map[string]P) Factory[P] {
+func Map[P any](t Test, params ...map[string]P) Factory[P] {
 	t.Helper()
 
 	return Any[P](t, maps.Add(maps.Copy(params[0]), params[1:]...))
@@ -181,7 +180,7 @@ func Map[P any](t *testing.T, params ...map[string]P) Factory[P] {
 // Slice creates a new parallel test runner with given test parameter sets
 // provided as a slice. The test runner is looking into the parameter set to
 // find a suitable test case name.
-func Slice[P any](t *testing.T, params ...[]P) Factory[P] {
+func Slice[P any](t Test, params ...[]P) Factory[P] {
 	t.Helper()
 
 	return Any[P](t, slices.Add(params...))
@@ -297,16 +296,16 @@ func (r *factory[P]) exec(
 		return
 	}
 
-	r.t.Run(name, r.wrap(param, call, parallel))
+	reflect.Run(r.t, name, r.wrap(param, call, parallel))
 }
 
 // wrap creates the wrapper method eventually executing the test.
 func (r *factory[P]) wrap(
 	param P, call ParamFunc[P], parallel bool,
-) func(*testing.T) {
+) func(Test) {
 	r.wg.Add(1)
 
-	return func(t *testing.T) {
+	return func(t Test) {
 		t.Helper()
 
 		New(t, parallel).