refactor: Move functions into test.go (#4)

Author: raeperd

contains.go

@@ -1,7 +1,9 @@
 package test
 
 import (
+	"bytes"
 	"reflect"
+	"strings"
 	"testing"
 )
 
@@ -21,6 +23,15 @@ func NotEqual[T comparable](t testing.TB, bad, got T) {
 	}
 }
 
+// DeepEqual calls t.Fatalf if want and got are different according to reflect.DeepEqual.
+func DeepEqual[T any](t testing.TB, want, got T) {
+	t.Helper()
+	// Pass as pointers to get around the nil-interface problem
+	if !reflect.DeepEqual(&want, &got) {
+		t.Fatalf("reflect.DeepEqual(%#v, %#v) == false", want, got)
+	}
+}
+
 // AllEqual calls t.Fatalf if want != got.
 func AllEqual[T comparable](t testing.TB, want, got []T) {
 	t.Helper()
@@ -97,3 +108,31 @@ func False(t testing.TB, value bool) {
 		t.Fatalf("got: true")
 	}
 }
+
+// Contains calls t.Fatalf if needle is not contained in the string or []byte haystack.
+func Contains[byteseq ~string | ~[]byte](t testing.TB, needle string, haystack byteseq) {
+	t.Helper()
+	if !contains(haystack, needle) {
+		t.Fatalf("%q not in %q", needle, haystack)
+	}
+}
+
+// NotContains calls t.Fatalf if needle is contained in the string or []byte haystack.
+func NotContains[byteseq ~string | ~[]byte](t testing.TB, needle string, haystack byteseq) {
+	t.Helper()
+	if contains(haystack, needle) {
+		t.Fatalf("%q in %q", needle, haystack)
+	}
+}
+
+func contains[byteseq ~string | ~[]byte](haystack byteseq, needle string) bool {
+	rv := reflect.ValueOf(haystack)
+	switch rv.Kind() {
+	case reflect.String:
+		return strings.Contains(rv.String(), needle)
+	case reflect.Slice:
+		return bytes.Contains(rv.Bytes(), []byte(needle))
+	default:
+		panic("unreachable")
+	}
+}

deep_equal.go

@@ -16,6 +16,9 @@ func Example() {
 	test.NotEqual(t, "hello", "world")     // good
 	test.NotEqual(t, "goodbye", "goodbye") // bad
 
+	test.DeepEqual(t, map[int]bool{1: true, 2: false}, map[int]bool{1: true, 2: false}) // good
+	test.DeepEqual(t, nil, []int{})                                                     // bad
+
 	s := []int{1, 2, 3}
 	test.AllEqual(t, []int{1, 2, 3}, s) // good
 	test.AllEqual(t, []int{3, 2, 1}, s) // bad
@@ -37,6 +40,7 @@ func Example() {
 	// Output:
 	// want: hello; got: world
 	// got: goodbye
+	// reflect.DeepEqual([]int(nil), []int{}) == false
 	// want: [3 2 1]; got: [1 2 3]
 	// got: <nil>
 	// got: (O_o)

deep_equal_example_test.go

@@ -4,33 +4,22 @@ import (
 	"errors"
 	"fmt"
 	"io"
+	"runtime"
 	"strings"
+	"sync"
 	"testing"
 	"time"
 
 	"github.com/raeperd/test"
 )
 
-type testingTB struct {
-	testing.TB
-	failed bool
-	w      io.Writer
-}
-
-func (t *testingTB) Helper() {}
-
-func (t *testingTB) Fatalf(format string, args ...any) {
-	t.failed = true
-	fmt.Fprintf(t.w, format, args...)
-}
-
 func Test(t *testing.T) {
 	beOkay := func(callback func(tb testing.TB)) {
 		t.Helper()
 		var buf strings.Builder
-		tb := &testingTB{w: &buf}
-		callback(tb)
-		if tb.failed {
+		mt := &mockingT{w: &buf}
+		callback(mt)
+		if mt.Failed() {
 			t.Fatal("failed too soon")
 		}
 		if buf.String() != "" {
@@ -47,9 +36,9 @@ func Test(t *testing.T) {
 	beBad := func(callback func(tb testing.TB)) {
 		t.Helper()
 		var buf strings.Builder
-		tb := &testingTB{w: &buf}
-		callback(tb)
-		if !tb.failed {
+		mt := &mockingT{w: &buf}
+		callback(mt)
+		if !mt.Failed() {
 			t.Fatal("did not fail")
 		}
 		if buf.String() == "" {
@@ -65,3 +54,66 @@ func Test(t *testing.T) {
 	beBad(func(tb testing.TB) { test.True(tb, false) })
 	beBad(func(tb testing.TB) { test.False(tb, true) })
 }
+
+type mockingT struct {
+	testing.T
+	sync.RWMutex
+	failed   bool
+	cleanups []func()
+	w        io.Writer
+}
+
+func (m *mockingT) setFailed(b bool) {
+	m.Lock()
+	defer m.Unlock()
+	m.failed = b
+}
+
+func (m *mockingT) Failed() bool {
+	m.RLock()
+	defer m.RUnlock()
+	return m.failed
+}
+
+func (m *mockingT) Run(name string, f func(t *testing.T)) {
+	m.cleanups = nil
+	m.setFailed(false)
+	ch := make(chan struct{})
+	defer func() {
+		for _, f := range m.cleanups {
+			defer f()
+		}
+	}()
+	// Use a goroutine so Fatalf can call Goexit
+	go func() {
+		defer close(ch)
+		f(&m.T)
+	}()
+	<-ch
+}
+
+func (m *mockingT) Cleanup(f func()) {
+	m.cleanups = append(m.cleanups, f)
+}
+
+func (*mockingT) Log(args ...any) {
+	fmt.Println(args...)
+}
+
+func (*mockingT) Helper() {}
+
+func (m *mockingT) Fatalf(format string, args ...any) {
+	m.setFailed(true)
+	if m.w != nil {
+		fmt.Fprintf(m.w, format, args...)
+		// Do not call runtime.Goexit here, so that caller can read the output
+	} else {
+		m.Errorf(format, args...)
+		runtime.Goexit()
+	}
+}
+
+func (m *mockingT) Errorf(format string, args ...any) {
+	m.setFailed(true)
+	fmt.Printf(format+"\n", args...)
+}