Add be.Match

Author: earthboundkid

README.md

@@ -53,15 +53,15 @@ be.NilErr(t, err)   // bad
 be.Nonzero(t, err) // good
 ```
 
-Check substring containment:
+Check for regexp matching:
 
 ```go
-be.In(t, "world", "hello, world") // good
-be.In(t, "World", "hello, world") // bad
-// t.Fatal("World" not in "hello, world")
-be.NotIn(t, "\x01", []byte("\a\b\x00\r\t")) // good
-be.NotIn(t, "\x00", []byte("\a\b\x00\r\t")) // bad
-// t.Fatal("\x00" in "\a\b\x00\r\t")
+be.Match(t, `world`, "hello, world")  // good
+be.Match(t, `World`, "hello, world")  // bad
+// t.Fatal(`/World/ !~ "hello, world"`)
+be.Match(t, `^\W*$`, []byte("\a\b\x00\r\t")) // good
+be.Match(t, `^\W*$`, []byte("\a\bo\r\t"))    // bad
+// t.Fatal(`/^\W*$/ !~ "\a\bo\r\t"`)
 ```
 
 Check how long something rangeable is:

be_example_test.go

@@ -35,10 +35,10 @@ func Example() {
 
 	type mytype string
 	var mystring mytype = "hello, world"
-	be.In(t, "world", mystring)                 // good
-	be.In(t, "World", mystring)                 // bad
-	be.NotIn(t, "\x01", []byte("\a\b\x00\r\t")) // good
-	be.NotIn(t, "\x00", []byte("\a\b\x00\r\t")) // bad
+	be.Match(t, `world`, mystring)               // good
+	be.Match(t, `World`, mystring)               // bad
+	be.Match(t, `^\W*$`, []byte("\a\b\x00\r\t")) // good
+	be.Match(t, `^\W*$`, []byte("\a\bo\r\t"))    // bad
 
 	seq := strings.FieldsSeq("1 2 3 4")
 	be.EqualLength(t, 4, seq)     // good
@@ -55,8 +55,8 @@ func Example() {
 	// got: <nil>
 	// got errors.Is(<nil>, permission denied) == false
 	// got errors.As((O_o), **fs.PathError) == false
-	// "World" not in "hello, world"
-	// "\x00" in "\a\b\x00\r\t"
+	// /World/ !~ "hello, world"
+	// /^\W*$/ !~ "\a\bo\r\t"
 	// want len(seq) == 1; got at least 2
 	// want len(seq) >= 5; got 4
 	// want len(seq) >= 4; got 3

be_test.go

@@ -48,6 +48,10 @@ func Test(t *testing.T) {
 			seq2 := maps.All(map[int]int{1: 1})
 			be.EqualLength(tb, 1, seq2)
 		},
+		func(tb testing.TB) {
+			be.In(tb, "world", "Hello, world!")
+			be.NotIn(tb, "\x01", []byte("\a\b\x00\r\t"))
+		},
 	}
 
 	for _, test := range okayTests {
@@ -88,6 +92,12 @@ func Test(t *testing.T) {
 			close(ch)
 			be.EqualLength(tb, 1, ch)
 		},
+		func(tb testing.TB) {
+			be.In(tb, "World", "Hello, world!")
+		},
+		func(tb testing.TB) {
+			be.NotIn(tb, "\x00", []byte("\a\b\x00\r\t"))
+		},
 	}
 
 	for _, test := range badTests {

len_test.go

@@ -0,0 +1,28 @@
+package be
+
+import (
+	"reflect"
+	"regexp"
+	"testing"
+)
+
+// Match calls t.Fatalf if got does not match the [regexp] pattern.
+//
+// The pattern must compile.
+func Match[byteseq ~string | ~[]byte](t testing.TB, pattern string, got byteseq) {
+	t.Helper()
+	reg := regexp.MustCompile(pattern)
+	if !match(reg, got) {
+		t.Fatalf("/%s/ !~ %q", pattern, got)
+	}
+}
+
+func match[byteseq ~string | ~[]byte](reg *regexp.Regexp, got byteseq) bool {
+	switch rv := reflect.ValueOf(got); rv.Kind() {
+	case reflect.String:
+		return reg.MatchString(rv.String())
+	case reflect.Slice:
+		return reg.Match(rv.Bytes())
+	}
+	panic("unreachable")
+}

match.go

@@ -0,0 +1,25 @@
+package be_test
+
+import (
+	"testing"
+
+	"github.com/carlmjohnson/be"
+)
+
+func TestLen(t *testing.T) {
+	// Make sure integers aren't treated as rangeable
+	be.Nonzero(t, be.Panicked(func() {
+		be.EqualLength(t, 0, 0)
+	}))
+}
+
+func TestMatch(t *testing.T) {
+	// Make sure bad regexp patterns panic
+	pval := be.Panicked(func() {
+		be.Match(t, `\`, "")
+	})
+	be.Nonzero(t, pval)
+	s, ok := pval.(string)
+	be.True(t, ok)
+	be.Match(t, `^regexp: Compile\(`, s)
+}