refector: add function test.

Author: ghosind

builtin.go

@@ -122,7 +122,7 @@ func NotEqualNow(t *testing.T, actual, expect any, message ...string) error {
 func Match(t *testing.T, val string, pattern *regexp.Regexp, message ...string) error {
 	t.Helper()
 
-	return tryMatchRegexp(t, false, val, pattern, message...)
+	return tryMatchRegexp(t, false, val, pattern, "", message...)
 }
 
 // MatchNow tests whether the string matches the regular expression or not, and it will terminate
@@ -135,7 +135,7 @@ func Match(t *testing.T, val string, pattern *regexp.Regexp, message ...string)
 func MatchNow(t *testing.T, val string, pattern *regexp.Regexp, message ...string) error {
 	t.Helper()
 
-	return tryMatchRegexp(t, true, val, pattern, message...)
+	return tryMatchRegexp(t, true, val, pattern, "", message...)
 }
 
 // MatchString will compile the pattern and test whether the string matches the regular expression
@@ -146,9 +146,7 @@ func MatchNow(t *testing.T, val string, pattern *regexp.Regexp, message ...strin
 func MatchString(t *testing.T, val, pattern string, message ...string) error {
 	t.Helper()
 
-	regPattern := regexp.MustCompile(pattern)
-
-	return tryMatchRegexp(t, false, val, regPattern, message...)
+	return tryMatchRegexp(t, false, val, nil, pattern, message...)
 }
 
 // MatchStringNow will compile the pattern and test whether the string matches the regular
@@ -161,9 +159,7 @@ func MatchString(t *testing.T, val, pattern string, message ...string) error {
 func MatchStringNow(t *testing.T, val, pattern string, message ...string) error {
 	t.Helper()
 
-	regPattern := regexp.MustCompile(pattern)
-
-	return tryMatchRegexp(t, true, val, regPattern, message...)
+	return tryMatchRegexp(t, true, val, nil, pattern, message...)
 }
 
 // NotMatch tests whether the string matches the regular expression or not, and it set the result
@@ -175,7 +171,7 @@ func MatchStringNow(t *testing.T, val, pattern string, message ...string) error
 func NotMatch(t *testing.T, val string, pattern *regexp.Regexp, message ...string) error {
 	t.Helper()
 
-	return tryNotMatchRegexp(t, false, val, pattern, message...)
+	return tryNotMatchRegexp(t, false, val, pattern, "", message...)
 }
 
 // NotMatchNow tests whether the string matches the regular expression or not, and it will
@@ -188,7 +184,7 @@ func NotMatch(t *testing.T, val string, pattern *regexp.Regexp, message ...strin
 func NotMatchNow(t *testing.T, val string, pattern *regexp.Regexp, message ...string) error {
 	t.Helper()
 
-	return tryNotMatchRegexp(t, true, val, pattern, message...)
+	return tryNotMatchRegexp(t, true, val, pattern, "", message...)
 }
 
 // MatchString will compile the pattern and test whether the string matches the regular expression
@@ -200,9 +196,7 @@ func NotMatchNow(t *testing.T, val string, pattern *regexp.Regexp, message ...st
 func NotMatchString(t *testing.T, val, pattern string, message ...string) error {
 	t.Helper()
 
-	regPattern := regexp.MustCompile(pattern)
-
-	return tryNotMatchRegexp(t, false, val, regPattern, message...)
+	return tryNotMatchRegexp(t, false, val, nil, pattern, message...)
 }
 
 // NotMatchStringNow will compile the pattern and test whether the string matches the regular
@@ -216,9 +210,7 @@ func NotMatchString(t *testing.T, val, pattern string, message ...string) error
 func NotMatchStringNow(t *testing.T, val, pattern string, message ...string) error {
 	t.Helper()
 
-	regPattern := regexp.MustCompile(pattern)
-
-	return tryNotMatchRegexp(t, true, val, regPattern, message...)
+	return tryNotMatchRegexp(t, true, val, nil, pattern, message...)
 }
 
 // Nil tests whether a value is nil or not, and it'll fail when the value is not nil. It will

equal.go

@@ -63,29 +63,27 @@ func (a *Assertion) NotDeepEqualNow(actual, expect any, message ...string) error
 func tryDeepEqual(t *testing.T, failedNow bool, actual, expect any, message ...string) error {
 	t.Helper()
 
-	if reflect.DeepEqual(actual, expect) {
-		return nil
-	}
-
-	err := newAssertionError(fmt.Sprintf("%v == %v", actual, expect), message...)
-	failed(t, err, failedNow)
-
-	return err
+	return test(
+		t,
+		func() bool { return reflect.DeepEqual(actual, expect) },
+		failedNow,
+		fmt.Sprintf(defaultErrMessageEqual, actual, expect),
+		message...,
+	)
 }
 
 // tryNotDeepEqual try to testing the deeply inequality between actual and expect values, and it'll
 // fail if the values are deeply equal.
 func tryNotDeepEqual(t *testing.T, failedNow bool, actual, expect any, message ...string) error {
 	t.Helper()
 
-	if !reflect.DeepEqual(actual, expect) {
-		return nil
-	}
-
-	err := newAssertionError(fmt.Sprintf("%v != %v", actual, expect), message...)
-	failed(t, err, failedNow)
-
-	return err
+	return test(
+		t,
+		func() bool { return !reflect.DeepEqual(actual, expect) },
+		failedNow,
+		fmt.Sprintf(defaultErrMessageNotEqual, actual, expect),
+		message...,
+	)
 }
 
 // Equal tests the equality between actual and expect parameters. It'll set the result to fail if
@@ -150,29 +148,27 @@ func (a *Assertion) NotEqualNow(actual, expect any, message ...string) error {
 func tryEqual(t *testing.T, failedNow bool, actual, expect any, message ...string) error {
 	t.Helper()
 
-	if isEqual(actual, expect) {
-		return nil
-	}
-
-	err := newAssertionError(fmt.Sprintf("%v == %v", actual, expect), message...)
-	failed(t, err, failedNow)
-
-	return err
+	return test(
+		t,
+		func() bool { return isEqual(actual, expect) },
+		failedNow,
+		fmt.Sprintf(defaultErrMessageEqual, actual, expect),
+		message...,
+	)
 }
 
 // tryNotEqual try to testing the inequality between actual and expect values, and it'll fail if
 // the values are equal.
 func tryNotEqual(t *testing.T, failedNow bool, actual, expect any, message ...string) error {
 	t.Helper()
 
-	if !isEqual(actual, expect) {
-		return nil
-	}
-
-	err := newAssertionError(fmt.Sprintf("%v != %v", actual, expect), message...)
-	failed(t, err, failedNow)
-
-	return err
+	return test(
+		t,
+		func() bool { return !isEqual(actual, expect) },
+		failedNow,
+		fmt.Sprintf(defaultErrMessageNotEqual, actual, expect),
+		message...,
+	)
 }
 
 // Nil tests whether a value is nil or not, and it'll fail when the value is not nil. It will
@@ -245,28 +241,26 @@ func (a *Assertion) NotNilNow(val any, message ...string) error {
 func tryNil(t *testing.T, failedNow bool, val any, message ...string) error {
 	t.Helper()
 
-	if isNil(val) {
-		return nil
-	}
-
-	err := newAssertionError(fmt.Sprintf("expect nil, got %v", val), message...)
-	failed(t, err, failedNow)
-
-	return err
+	return test(
+		t,
+		func() bool { return isNil(val) },
+		failedNow,
+		fmt.Sprintf(defaultErrMessageNil, val),
+		message...,
+	)
 }
 
 // tryNotNil try to testing a value is nil or not, and it'll fail the value is not nil.
 func tryNotNil(t *testing.T, failedNow bool, val any, message ...string) error {
 	t.Helper()
 
-	if !isNil(val) {
-		return nil
-	}
-
-	err := newAssertionError("expect not nil, got nil", message...)
-	failed(t, err, failedNow)
-
-	return err
+	return test(
+		t,
+		func() bool { return !isNil(val) },
+		failedNow,
+		defaultErrMessageNotNil,
+		message...,
+	)
 }
 
 // True tests whether a value is truthy or not. It'll set the result to fail if the value is a
@@ -337,26 +331,28 @@ func (a *Assertion) NotTrueNow(val any, message ...string) error {
 func tryTrue(t *testing.T, failedNow bool, val any, message ...string) error {
 	t.Helper()
 
-	if isTrue(val) {
-		return nil
-	}
-
-	err := newAssertionError("the expression evaluated to a falsy value")
-	failed(t, err, failedNow)
-
-	return err
+	return test(
+		t,
+		func() bool {
+			return isTrue(val)
+		},
+		failedNow,
+		defaultErrMessageTrue,
+		message...,
+	)
 }
 
 // tryNotTrue try to testing a value is truthy or falsy, and it'll fail the value is truthy.
 func tryNotTrue(t *testing.T, failedNow bool, val any, message ...string) error {
 	t.Helper()
 
-	if !isTrue(val) {
-		return nil
-	}
-
-	err := newAssertionError("the expression evaluated to a truthy value")
-	failed(t, err, failedNow)
-
-	return err
+	return test(
+		t,
+		func() bool {
+			return !isTrue(val)
+		},
+		failedNow,
+		defaultErrMessageNotTrue,
+		message...,
+	)
 }

error.go

@@ -1,5 +1,18 @@
 package assert
 
+const (
+	defaultErrMessageEqual    string = "%v == %v"
+	defaultErrMessageNotEqual string = "%v != %v"
+	defaultErrMessageMatch    string = "the input did not match the regular expression"
+	defaultErrMessageNotMatch string = "the input match the regular expression"
+	defaultErrMessageNil      string = "expect nil, got %v"
+	defaultErrMessageNotNil   string = "expect not nil, got nil"
+	defaultErrMessagePanic    string = "missing expected panic"
+	defaultErrMessageNotPanic string = "got unwanted error: %v"
+	defaultErrMessageTrue     string = "the expression evaluated to a falsy value"
+	defaultErrMessageNotTrue  string = "the expression evaluated to a truthy value"
+)
+
 // AssertionError indicates the failure of an assertion.
 type AssertionError struct {
 	message string

panic.go

@@ -81,7 +81,7 @@ func tryPanic(t *testing.T, failedNow bool, fn func(), message ...string) error
 		return nil
 	}
 
-	err := newAssertionError("missing expected panic", message...)
+	err := newAssertionError(defaultErrMessagePanic, message...)
 	failed(t, err, failedNow)
 
 	return err
@@ -97,7 +97,7 @@ func tryNotPanic(t *testing.T, failedNow bool, fn func(), message ...string) err
 		return nil
 	}
 
-	err := newAssertionError(fmt.Sprintf("got unwanted error: %v", e), message...)
+	err := newAssertionError(fmt.Sprintf(defaultErrMessageNotPanic, e), message...)
 	failed(t, err, failedNow)
 	return err
 }