feat: add support for benchmarks (#144)

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

Author: tkrop

.github/workflows/build.yaml

@@ -7,15 +7,15 @@ jobs:
   linux:
     runs-on: ubuntu-latest
     steps:
+    - name: Checkout code
+      uses: actions/checkout@v5
+
     - name: Set up Go
-      uses: actions/setup-go@v5
+      uses: actions/setup-go@v6
       with:
         go-version: 1.26
         cache: false
 
-    - name: Checkout code
-      uses: actions/checkout@v4
-
     - name: Build and tests
       env:
         CODACY_PROJECT_TOKEN: ${{ secrets.CODACY_PROJECT_TOKEN }}
@@ -31,15 +31,15 @@ jobs:
   # macos:
   #   runs-on: macos-latest
   #   steps:
+  #   - name: Checkout code
+  #     uses: actions/checkout@v5
+
   #   - name: Set up Go
-  #     uses: actions/setup-go@v5
+  #     uses: actions/setup-go@v6
   #     with:
   #       go-version: 1.26
   #       cache: false
 
-  #   - name: Checkout code
-  #     uses: actions/checkout@v4
-
   #   - name: Build and tests
   #     env:
   #       BASH_COMPAT: 3.2
@@ -53,14 +53,14 @@ jobs:
     permissions:
       contents: write
     steps:
+    - name: Checkout code
+      uses: actions/checkout@v5
+
     - name: Set up Go
-      uses: actions/setup-go@v5
+      uses: actions/setup-go@v6
       with:
         go-version: 1.26
 
-    - name: Checkout code
-      uses: actions/checkout@v4
-
     - name: Release new version
       env:
         GH_TOKEN: ${{ github.token }}

Makefile

@@ -18,7 +18,7 @@ TMPDIR ?= /tmp
 # Setup default go-make installation flags.
 INSTALL_FLAGS ?= -mod=readonly -buildvcs=auto
 # Setup go-make version to use desired build and config scripts.
-GOMAKE_DEP ?= github.com/tkrop/go-make@v0.2.6
+GOMAKE_DEP ?= github.com/tkrop/go-make@v0.3.0
 # Request targets from go-make show-targets target.
 TARGETS := $(shell command -v $(GOBIN)/go-make >/dev/null || \
 	$(GO) install $(INSTALL_FLAGS) $(GOMAKE_DEP) >&2 && \

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.

go.mod

@@ -1,6 +1,6 @@
 module github.com/tkrop/go-testing
 
-go 1.26.2
+go 1.26.3
 
 require (
 	github.com/davecgh/go-spew v1.1.2-0.20180830191138-d8f796af33cc
@@ -10,12 +10,12 @@ require (
 	github.com/stretchr/testify v1.11.1
 	go.uber.org/mock v0.6.0
 	golang.org/x/text v0.30.0
-	golang.org/x/tools v0.44.0
+	golang.org/x/tools v0.45.0
 )
 
 require (
 	github.com/h2non/parth v0.0.0-20190131123155-b4df798d6542 // indirect
-	golang.org/x/mod v0.35.0 // indirect
+	golang.org/x/mod v0.36.0 // indirect
 	golang.org/x/sync v0.20.0 // indirect
 	gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c // indirect
 	gopkg.in/yaml.v3 v3.0.1 // indirect

go.sum

@@ -28,14 +28,14 @@ github.com/stretchr/testify v1.11.1 h1:7s2iGBzp5EwR7/aIZr8ao5+dra3wiQyKjjFuvgVKu
 github.com/stretchr/testify v1.11.1/go.mod h1:wZwfW3scLgRK+23gO65QZefKpKQRnfz6sD981Nm4B6U=
 go.uber.org/mock v0.6.0 h1:hyF9dfmbgIX5EfOdasqLsWD6xqpNZlXblLB/Dbnwv3Y=
 go.uber.org/mock v0.6.0/go.mod h1:KiVJ4BqZJaMj4svdfmHM0AUx4NJYO8ZNpPnZn1Z+BBU=
-golang.org/x/mod v0.35.0 h1:Ww1D637e6Pg+Zb2KrWfHQUnH2dQRLBQyAtpr/haaJeM=
-golang.org/x/mod v0.35.0/go.mod h1:+GwiRhIInF8wPm+4AoT6L0FA1QWAad3OMdTRx4tFYlU=
+golang.org/x/mod v0.36.0 h1:JJjpVx6myfUsUdAzZuOSTTmRE0PfZeNWzzvKrP7amb4=
+golang.org/x/mod v0.36.0/go.mod h1:moc6ELqsWcOw5Ef3xVprK5ul/MvtVvkIXLziUOICjUQ=
 golang.org/x/sync v0.20.0 h1:e0PTpb7pjO8GAtTs2dQ6jYa5BWYlMuX047Dco/pItO4=
 golang.org/x/sync v0.20.0/go.mod h1:9xrNwdLfx4jkKbNva9FpL6vEN7evnE43NNNJQ2LF3+0=
 golang.org/x/text v0.30.0 h1:yznKA/E9zq54KzlzBEAWn1NXSQ8DIp/NYMy88xJjl4k=
 golang.org/x/text v0.30.0/go.mod h1:yDdHFIX9t+tORqspjENWgzaCVXgk0yYnYuSZ8UzzBVM=
-golang.org/x/tools v0.44.0 h1:UP4ajHPIcuMjT1GqzDWRlalUEoY+uzoZKnhOjbIPD2c=
-golang.org/x/tools v0.44.0/go.mod h1:KA0AfVErSdxRZIsOVipbv3rQhVXTnlU6UhKxHd1seDI=
+golang.org/x/tools v0.45.0 h1:18qN3FAooORvApf5XjCXgsuayZOEtXf6JK18I3+ONa8=
+golang.org/x/tools v0.45.0/go.mod h1:LuUGqqaXcXMEFEruIVJVm5mgDD8vww/z/SR1gQ4uE/0=
 gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
 gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c h1:Hei/4ADfdWqJk1ZMxUNpqntNwaWcugrBjAiHlqqRiVk=
 gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c/go.mod h1:JHkPIbrfpd72SG/EVd6muEfDQjcINNoR0C8j2r3qZ4Q=

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(name + ": target must not be nil")
+	}
+
+	method := value.MethodByName("Run")
+	if !method.IsValid() {
+		panic(name + ": 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(name + ": target does not implement type [" +
+				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,67 @@ 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
+}
+
+// failer is a test double that does not implement the expected type.
+type failer struct{}
+
+func (failer) Run(_ string, call func(failer)) bool {
+	call(failer{})
+
+	return true
+}
+
+type RunParams struct {
+	setup      mock.SetupFunc
+	target     any
+	expectCall bool
+}
+
+var runTestCases = map[string]RunParams{
+	"nil-target": {
+		setup: test.Panic("call: target must not be nil"),
+	},
+	"no-run-method": {
+		target: struct{}{},
+		setup: test.Panic("call: target does not implement method " +
+			"[struct {} => Run]"),
+	},
+	"not-type": {
+		target: failer{},
+		setup: test.Panic("call: target does not implement type " +
+			"[reflect_test.failer => *reflect_test.runner]"),
+	},
+
+	"run": {
+		target:     &runner{},
+		expectCall: true,
+	},
+}
+
+func TestRun(t *testing.T) {
+	test.Map(t, runTestCases).
+		Run(func(t test.Test, param RunParams) {
+			// Given
+			mock.NewMocks(t).Expect(param.setup)
+
+			// When
+			reflect.Run(param.target, "call", func(inner *runner) {
+				inner.called = true
+			})
+
+			// Then
+			assert.Equal(t, param.expectCall,
+				param.target != nil && param.target.(*runner).called)
+		})
+}

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).