feat: add XXXNow functions to stop execution if assert failed.

Author: ghosind

builtin.go

@@ -4,36 +4,82 @@ import (
 	"testing"
 )
 
-// DeepEqual tests deeply equality between actual and expect parameters.
+// DeepEqual tests the deep equality between actual and expect parameters. It'll set the result to
+// fail if they are not deeply equal, and it doesn't stop the execution.
 func DeepEqual(t *testing.T, actual, expect any, message ...string) error {
 	return tryDeepEqual(t, false, actual, expect, message...)
 }
 
-// NotDeepEqual tests deeply inequality between actual and expected parameters.
+// DeepEqualNow tests the deep equality between actual and expect parameters, and it'll stop the
+// execution if they are not deeply equal.
+func DeepEqualNow(t *testing.T, actual, expect any, message ...string) error {
+	return tryDeepEqual(t, true, actual, expect, message...)
+}
+
+// NotDeepEqual tests the deep inequality between actual and expected parameters. It'll set the
+// result to fail if they are deeply equal, but it doesn't stop the execution.
 func NotDeepEqual(t *testing.T, actual, expect any, message ...string) error {
 	return tryNotDeepEqual(t, false, actual, expect, message...)
 }
 
+// NotDeepEqualNow tests the deep inequality between actual and expected parameters, and it'll stop
+// the execution if they are deeply equal.
+func NotDeepEqualNow(t *testing.T, actual, expect any, message ...string) error {
+	return tryNotDeepEqual(t, true, actual, expect, 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.
 func Nil(t *testing.T, val any, message ...string) error {
 	return tryNil(t, false, val, message...)
 }
 
+// NilNow 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.
+//
+// This function will set the result to fail, and stop the execution if the value is not nil.
+func NilNow(t *testing.T, val any, message ...string) error {
+	return tryNil(t, true, val, message...)
+}
+
 // NotNil tests whether a value is nil or not, and it'll fail when the value is nil. It will
 // always return true if the value is a bool, an integer, a floating number, a complex, or a
 // string.
 func NotNil(t *testing.T, val any, message ...string) error {
 	return tryNotNil(t, false, val, message...)
 }
 
-// Panic expects the function fn to panic.
+// NotNilNow tests whether a value is nil or not, and it'll fail when the value is nil. It will
+// always return true if the value is a bool, an integer, a floating number, a complex, or a
+// string.
+//
+// This function will set the result to fail, and stop the execution if the value is nil.
+func NotNilNow(t *testing.T, val any, message ...string) error {
+	return tryNotNil(t, true, val, message...)
+}
+
+// Panic expects the function fn to panic, and it'll set the result to fail if the function doesn't
+// panic.
 func Panic(t *testing.T, fn func(), message ...string) error {
 	return tryPanic(t, false, fn, message...)
 }
 
-// NotPanic asserts that the function fn does not panic.
+// PanicNow expects the function fn to panic. It'll set the result to fail if the function doesn't
+// panic, and stop the execution.
+func PanicNow(t *testing.T, fn func(), message ...string) error {
+	return tryPanic(t, true, fn, message...)
+}
+
+// NotPanic asserts that the function fn does not panic, and it'll set the result to fail if the
+// function panic.
 func NotPanic(t *testing.T, fn func(), message ...string) error {
 	return tryNotPanic(t, false, fn, message...)
 }
+
+// NotPanicNow asserts that the function fn does not panic. It'll set the result to fail if the
+// function panic, and it also stops the execution.
+func NotPanicNow(t *testing.T, fn func(), message ...string) error {
+	return tryNotPanic(t, false, fn, message...)
+}

equal.go

@@ -6,16 +6,30 @@ import (
 	"testing"
 )
 
-// DeepEqual tests deeply equality between actual and expect parameters.
+// DeepEqual tests the deep equality between actual and expect parameters. It'll set the result to
+// fail if they are not deeply equal, and it doesn't stop the execution.
 func (a *Assertion) DeepEqual(actual, expect any, message ...string) error {
 	return tryDeepEqual(a.t, false, actual, expect, message...)
 }
 
-// NotDeepEqual tests deeply inequality between actual and expected parameters.
+// DeepEqualNow tests the deep equality between actual and expect parameters, and it'll stop the
+// execution if they are not deeply equal.
+func (a *Assertion) DeepEqualNow(actual, expect any, message ...string) error {
+	return tryDeepEqual(a.t, true, actual, expect, message...)
+}
+
+// NotDeepEqual tests the deep inequality between actual and expected parameters. It'll set the
+// result to fail if they are deeply equal, but it doesn't stop the execution.
 func (a *Assertion) NotDeepEqual(actual, expect any, message ...string) error {
 	return tryNotDeepEqual(a.t, false, actual, expect, message...)
 }
 
+// NotDeepEqualNow tests the deep inequality between actual and expected parameters, and it'll stop
+// the execution if they are deeply equal.
+func (a *Assertion) NotDeepEqualNow(actual, expect any, message ...string) error {
+	return tryNotDeepEqual(a.t, true, actual, expect, message...)
+}
+
 // tryDeepEqual try to testing the deeply equality between actual and expect values, and it'll
 // fail if the values are not deeply equal.
 func tryDeepEqual(t *testing.T, failedNow bool, actual, expect any, message ...string) error {
@@ -49,13 +63,31 @@ func (a *Assertion) Nil(val any, message ...string) error {
 	return tryNil(a.t, false, val, message...)
 }
 
+// NilNow 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.
+//
+// This function will set the result to fail, and stop the execution if the value is not nil.
+func (a *Assertion) NilNow(val any, message ...string) error {
+	return tryNil(a.t, true, val, message...)
+}
+
 // NotNil tests whether a value is nil or not, and it'll fail when the value is nil. It will
 // always return true if the value is a bool, an integer, a floating number, a complex, or a
 // string.
 func (a *Assertion) NotNil(val any, message ...string) error {
 	return tryNotNil(a.t, false, val, message...)
 }
 
+// NotNilNow tests whether a value is nil or not, and it'll fail when the value is nil. It will
+// always return true if the value is a bool, an integer, a floating number, a complex, or a
+// string.
+//
+// This function will set the result to fail, and stop the execution if the value is nil.
+func (a *Assertion) NotNilNow(val any, message ...string) error {
+	return tryNotNil(a.t, true, val, message...)
+}
+
 // tryNil try to testing a value is nil or not, and it'll fail the value is nil.
 func tryNil(t *testing.T, failedNow bool, val any, message ...string) error {
 	if isNil(val) {

panic.go

@@ -5,16 +5,30 @@ import (
 	"testing"
 )
 
-// Panic expects the function fn to panic.
+// Panic expects the function fn to panic, and it'll set the result to fail if the function doesn't
+// panic.
 func (a *Assertion) Panic(fn func(), message ...string) error {
 	return tryPanic(a.t, false, fn, message...)
 }
 
-// NotPanic asserts that the function fn does not panic.
+// PanicNow expects the function fn to panic. It'll set the result to fail if the function doesn't
+// panic, and stop the execution.
+func (a *Assertion) PanicNow(fn func(), message ...string) error {
+	return tryPanic(a.t, true, fn, message...)
+}
+
+// NotPanic asserts that the function fn does not panic, and it'll set the result to fail if the
+// function panic.
 func (a *Assertion) NotPanic(fn func(), message ...string) error {
 	return tryNotPanic(a.t, false, fn, message...)
 }
 
+// NotPanicNow asserts that the function fn does not panic. It'll set the result to fail if the
+// function panic, and it also stops the execution.
+func (a *Assertion) NotPanicNow(fn func(), message ...string) error {
+	return tryNotPanic(a.t, false, fn, message...)
+}
+
 // tryPanic executes the function fn, and try to catching the panic error. It expect the function
 // fn to panic, and returns error if fn does not panic.
 func tryPanic(t *testing.T, failedNow bool, fn func(), message ...string) error {