feat: add regular expression assertions.

Author: ghosind

README.md

@@ -105,6 +105,8 @@ func TestExample(t *testing.T) {
 
 - [`DeepEqual`](https://pkg.go.dev/github.com/ghosind/go-assert#Assertion.DeepEqual) and [`NotDeepEqual`](https://pkg.go.dev/github.com/ghosind/go-assert#Assertion.NotDeepEqual): assert the deep equality or inequality.
 - [`Equal`](https://pkg.go.dev/github.com/ghosind/go-assert#Assertion.Equal) and [`NotEqual`](https://pkg.go.dev/github.com/ghosind/go-assert#Assertion.NotEqual): assert the equality or inequality.
+- [`Match`](https://pkg.go.dev/github.com/ghosind/go-assert#Assertion.Match) and [`NotMatch`](https://pkg.go.dev/github.com/ghosind/go-assert#Assertion.NotMatch): assert whether the string matches the regular expression pattern or not.
+- [`MatchString`](https://pkg.go.dev/github.com/ghosind/go-assert#Assertion.MatchString) and [`NotMatchString`](https://pkg.go.dev/github.com/ghosind/go-assert#Assertion.NotMatchString): compile the regular expression pattern and assert whether the string matches the pattern or not.
 - [`Nil`](https://pkg.go.dev/github.com/ghosind/go-assert#Assertion.Nil) and [`NotNil`](https://pkg.go.dev/github.com/ghosind/go-assert#Assertion.NotNil): assert the value is nil or not.
 - [`Panic`](https://pkg.go.dev/github.com/ghosind/go-assert#Assertion.Panic) and [`NotPanic`](https://pkg.go.dev/github.com/ghosind/go-assert#Assertion.NotPanic): assert the function will panic or not.
 - [`True`](https://pkg.go.dev/github.com/ghosind/go-assert#Assertion.True) and [`NotTrue`](https://pkg.go.dev/github.com/ghosind/go-assert#Assertion.NotTrue): assert the truthy of the value.

builtin.go

@@ -1,6 +1,7 @@
 package assert
 
 import (
+	"regexp"
 	"testing"
 )
 
@@ -68,6 +69,81 @@ func NotEqualNow(t *testing.T, actual, expect any, message ...string) error {
 	return tryNotEqual(t, true, actual, expect, message...)
 }
 
+// Match tests whether the string matches the regular expression or not.
+func Match(t *testing.T, val string, pattern *regexp.Regexp, message ...string) error {
+	t.Helper()
+
+	return tryMatchRegexp(t, false, val, pattern, message...)
+}
+
+// MatchNow tests whether the string matches the regular expression or not, and it will terminate
+// the execution if it does not match.
+func MatchNow(t *testing.T, val string, pattern *regexp.Regexp, message ...string) error {
+	t.Helper()
+
+	return tryMatchRegexp(t, true, val, pattern, message...)
+}
+
+// MatchString will compile the pattern and test whether the string matches the regular expression
+// or not. It will panic if the pattern is not a valid regular expression.
+func MatchString(t *testing.T, val, pattern string, message ...string) error {
+	t.Helper()
+
+	regPattern := regexp.MustCompile(pattern)
+
+	return tryMatchRegexp(t, false, val, regPattern, message...)
+}
+
+// MatchStringNow will compile the pattern and test whether the string matches the regular
+// expression or not. It will terminate the execution if it does not match, and it will panic if
+// the pattern is not a valid regular expression.
+func MatchStringNow(t *testing.T, val, pattern string, message ...string) error {
+	t.Helper()
+
+	regPattern := regexp.MustCompile(pattern)
+
+	return tryMatchRegexp(t, true, val, regPattern, message...)
+}
+
+// NotMatch tests whether the string matches the regular expression or not, and it set the result
+// to fail if the string matches the pattern.
+func NotMatch(t *testing.T, val string, pattern *regexp.Regexp, message ...string) error {
+	t.Helper()
+
+	return tryNotMatchRegexp(t, false, val, pattern, message...)
+}
+
+// NotMatchNow tests whether the string matches the regular expression or not, and it will
+// terminate the execution if the string matches the pattern.
+func NotMatchNow(t *testing.T, val string, pattern *regexp.Regexp, message ...string) error {
+	t.Helper()
+
+	return tryNotMatchRegexp(t, true, val, pattern, message...)
+}
+
+// MatchString will compile the pattern and test whether the string matches the regular expression
+// or not, and it set the result to fail if the string matches the pattern. It will also panic if
+// the pattern is not a valid regular expression.
+func NotMatchString(t *testing.T, val, pattern string, message ...string) error {
+	t.Helper()
+
+	regPattern := regexp.MustCompile(pattern)
+
+	return tryNotMatchRegexp(t, false, val, regPattern, message...)
+}
+
+// NotMatchStringNow will compile the pattern and test whether the string matches the regular
+// expression or not, and it set the result to fail if the string matches the pattern. It will
+// terminate the execution if the string matches the pattern, and it will panic if the pattern is
+// not a valid regular expression.
+func NotMatchStringNow(t *testing.T, val, pattern string, message ...string) error {
+	t.Helper()
+
+	regPattern := regexp.MustCompile(pattern)
+
+	return tryNotMatchRegexp(t, true, val, regPattern, message...)
+}
+
 // Nil tests whether a value is nil or not, and it'll fail when the value is not nil. It will
 // always return false if the value is a bool, an integer, a floating number, a complex, or a
 // string.

regexp.go

@@ -0,0 +1,121 @@
+package assert
+
+import (
+	"regexp"
+	"testing"
+)
+
+// Match tests whether the string matches the regular expression or not.
+func (a *Assertion) Match(val string, pattern *regexp.Regexp, message ...string) error {
+	a.Helper()
+
+	return tryMatchRegexp(a.T, false, val, pattern, message...)
+}
+
+// MatchNow tests whether the string matches the regular expression or not, and it will terminate
+// the execution if it does not match.
+func (a *Assertion) MatchNow(val string, pattern *regexp.Regexp, message ...string) error {
+	a.Helper()
+
+	return tryMatchRegexp(a.T, true, val, pattern, message...)
+}
+
+// MatchString will compile the pattern and test whether the string matches the regular expression
+// or not. It will panic if the pattern is not a valid regular expression.
+func (a *Assertion) MatchString(val, pattern string, message ...string) error {
+	a.Helper()
+
+	regPattern := regexp.MustCompile(pattern)
+
+	return tryMatchRegexp(a.T, false, val, regPattern, message...)
+}
+
+// MatchStringNow will compile the pattern and test whether the string matches the regular
+// expression or not. It will terminate the execution if it does not match, and it will panic if
+// the pattern is not a valid regular expression.
+func (a *Assertion) MatchStringNow(val, pattern string, message ...string) error {
+	a.Helper()
+
+	regPattern := regexp.MustCompile(pattern)
+
+	return tryMatchRegexp(a.T, true, val, regPattern, message...)
+}
+
+// NotMatch tests whether the string matches the regular expression or not, and it set the result
+// to fail if the string matches the pattern.
+func (a *Assertion) NotMatch(val string, pattern *regexp.Regexp, message ...string) error {
+	a.Helper()
+
+	return tryNotMatchRegexp(a.T, false, val, pattern, message...)
+}
+
+// NotMatchNow tests whether the string matches the regular expression or not, and it will
+// terminate the execution if the string matches the pattern.
+func (a *Assertion) NotMatchNow(val string, pattern *regexp.Regexp, message ...string) error {
+	a.Helper()
+
+	return tryNotMatchRegexp(a.T, true, val, pattern, message...)
+}
+
+// MatchString will compile the pattern and test whether the string matches the regular expression
+// or not, and it set the result to fail if the string matches the pattern. It will also panic if
+// the pattern is not a valid regular expression.
+func (a *Assertion) NotMatchString(val, pattern string, message ...string) error {
+	a.Helper()
+
+	regPattern := regexp.MustCompile(pattern)
+
+	return tryNotMatchRegexp(a.T, false, val, regPattern, message...)
+}
+
+// NotMatchStringNow will compile the pattern and test whether the string matches the regular
+// expression or not, and it set the result to fail if the string matches the pattern. It will
+// terminate the execution if the string matches the pattern, and it will panic if the pattern is
+// not a valid regular expression.
+func (a *Assertion) NotMatchStringNow(val, pattern string, message ...string) error {
+	a.Helper()
+
+	regPattern := regexp.MustCompile(pattern)
+
+	return tryNotMatchRegexp(a.T, true, val, regPattern, message...)
+}
+
+// tryMatchRegexp tries to test whether the string matches the regular expression pattern or not,
+// and it'll fail if the string does not match.
+func tryMatchRegexp(
+	t *testing.T,
+	failedNow bool,
+	val string,
+	pattern *regexp.Regexp,
+	message ...string,
+) error {
+	t.Helper()
+
+	if pattern.Match([]byte(val)) {
+		return nil
+	}
+
+	err := newAssertionError("The input did not match the regular expression", message...)
+	failed(t, err, failedNow)
+	return err
+}
+
+// tryNotMatchRegexp tries to test whether the string matches the regular expression pattern or
+// not, and it'll fail if the string matches the pattern.
+func tryNotMatchRegexp(
+	t *testing.T,
+	failedNow bool,
+	val string,
+	pattern *regexp.Regexp,
+	message ...string,
+) error {
+	t.Helper()
+
+	if !pattern.Match([]byte(val)) {
+		return nil
+	}
+
+	err := newAssertionError("The input match the regular expression", message...)
+	failed(t, err, failedNow)
+	return err
+}