- Add utility functions under bdd package to circumvent unused variable errors in test

- Add utility functions under `bdd` package to produce `reflect.Type` for IsA() predicate
- Add logic and integration for IsA() predicate

Author: maargenton

pkg/bdd/utils.go

@@ -0,0 +1,14 @@
+package bdd
+
+import "reflect"
+
+// Used is a no-op function to mark variables as used, to avoid compiler while
+// in the middle of writing tests
+func Used(vv ...any) {}
+
+// TypeOf returns the reflect.Type for a given type T, for use with IsA()
+// predicate.
+func TypeOf[T any]() reflect.Type {
+	var p *T = nil
+	return reflect.TypeOf(p).Elem()
+}

pkg/bdd/utils_test.go

@@ -0,0 +1,26 @@
+package bdd_test
+
+import (
+	"io"
+	"reflect"
+	"testing"
+
+	"github.com/maargenton/go-testpredicate/pkg/bdd"
+	"github.com/maargenton/go-testpredicate/pkg/verify"
+)
+
+func TestUsed(t *testing.T) {
+	var v = 0 // bdd.Used() should suppress the 'declared and not used' error
+	bdd.Used(v)
+
+	// Nothing further to test here
+}
+
+func TestTypeOf(t *testing.T) {
+	verify.That(t, bdd.TypeOf[int]()).Eq(reflect.TypeOf(int(0)))
+	verify.That(t, bdd.TypeOf[string]()).Eq(reflect.TypeOf(""))
+	verify.That(t, bdd.TypeOf[float64]()).Eq(reflect.TypeOf(float64(0.0)))
+	verify.That(t, bdd.TypeOf[[]string]()).Eq(reflect.TypeOf([]string{}))
+
+	verify.That(t, bdd.TypeOf[io.Reader]()).ToString().Eq("io.Reader")
+}

pkg/utils/builder/builder_api.go

@@ -3,6 +3,8 @@
 package builder
 
 import (
+	"reflect"
+
 	"github.com/maargenton/go-testpredicate/pkg/utils/predicate"
 	"github.com/maargenton/go-testpredicate/pkg/utils/predicate/impl"
 )
@@ -528,3 +530,19 @@ func (b *Builder) Field(keypath string) *Builder {
 
 // From pkg/utils/predicate/impl/struct.go
 // ---------------------------------------------------------------------------
+
+// ---------------------------------------------------------------------------
+// From pkg/utils/predicate/impl/type.go
+
+// IsA tests if a value is of a given type.
+func (b *Builder) IsA(typ reflect.Type) *predicate.Predicate {
+	b.p.RegisterPredicate(impl.IsA(typ))
+	if b.t != nil {
+		b.t.Helper()
+		Evaluate(b)
+	}
+	return &b.p
+}
+
+// From pkg/utils/predicate/impl/type.go
+// ---------------------------------------------------------------------------

pkg/utils/predicate/impl/type.go

@@ -0,0 +1,34 @@
+package impl
+
+import (
+	"fmt"
+	"reflect"
+
+	"github.com/maargenton/go-testpredicate/pkg/utils/predicate"
+)
+
+// IsA tests if a value is of a given type.
+func IsA(typ reflect.Type) (desc string, f predicate.PredicateFunc) {
+	desc = fmt.Sprintf("{} is a %v", typ)
+
+	f = func(v interface{}) (r bool, ctx []predicate.ContextValue, err error) {
+		var t = reflect.TypeOf(v)
+
+		if t != nil {
+			if typ.Kind() == reflect.Interface {
+				if t.Implements(typ) {
+					return true, nil, nil
+				}
+			} else if t == typ {
+				return true, nil, nil
+			}
+		}
+
+		ctx = append(ctx, predicate.ContextValue{
+			Name:  "type",
+			Value: fmt.Sprintf("%T", v),
+		})
+		return false, ctx, nil
+	}
+	return
+}

pkg/utils/predicate/impl/type_test.go

@@ -0,0 +1,22 @@
+package impl_test
+
+import (
+	"io"
+	"strings"
+	"testing"
+
+	"github.com/maargenton/go-testpredicate/pkg/bdd"
+	"github.com/maargenton/go-testpredicate/pkg/utils/predicate/impl"
+)
+
+func TestIsA(t *testing.T) {
+	verifyPredicate(t, pr(impl.IsA(bdd.TypeOf[int]())), expectation{value: 123, pass: true})
+	verifyPredicate(t, pr(impl.IsA(bdd.TypeOf[string]())), expectation{value: "test", pass: true})
+
+	verifyPredicate(t, pr(impl.IsA(bdd.TypeOf[float64]())), expectation{value: 123.45, pass: true})
+	verifyPredicate(t, pr(impl.IsA(bdd.TypeOf[int]())), expectation{value: 123.45, pass: false})
+
+	var r = strings.NewReader("test")
+	verifyPredicate(t, pr(impl.IsA(bdd.TypeOf[io.Reader]())), expectation{value: r, pass: true})
+	verifyPredicate(t, pr(impl.IsA(bdd.TypeOf[io.Writer]())), expectation{value: r, pass: false})
+}