feat: mark helper functions.

Author: ghosind

builtin.go

@@ -7,31 +7,41 @@ import (
 // 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 {
+	t.Helper()
+
 	return tryDeepEqual(t, false, actual, expect, message...)
 }
 
 // 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 {
+	t.Helper()
+
 	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 {
+	t.Helper()
+
 	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 {
+	t.Helper()
+
 	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 {
+	t.Helper()
+
 	return tryNil(t, false, val, message...)
 }
 
@@ -41,13 +51,17 @@ func Nil(t *testing.T, val any, message ...string) error {
 //
 // 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 {
+	t.Helper()
+
 	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 {
+	t.Helper()
+
 	return tryNotNil(t, false, val, message...)
 }
 
@@ -57,29 +71,39 @@ func NotNil(t *testing.T, val any, message ...string) error {
 //
 // 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 {
+	t.Helper()
+
 	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 {
+	t.Helper()
+
 	return tryPanic(t, false, fn, message...)
 }
 
 // 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 {
+	t.Helper()
+
 	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 {
+	t.Helper()
+
 	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 {
+	t.Helper()
+
 	return tryNotPanic(t, false, fn, message...)
 }

equal.go

@@ -9,30 +9,40 @@ import (
 // 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 {
+	a.Helper()
+
 	return tryDeepEqual(a.T, false, actual, expect, message...)
 }
 
 // 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 {
+	a.Helper()
+
 	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 {
+	a.Helper()
+
 	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 {
+	a.Helper()
+
 	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 {
+	t.Helper()
+
 	if reflect.DeepEqual(actual, expect) {
 		return nil
 	}
@@ -46,6 +56,8 @@ func tryDeepEqual(t *testing.T, failedNow bool, actual, expect any, message ...s
 // 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
 	}
@@ -60,6 +72,8 @@ func tryNotDeepEqual(t *testing.T, failedNow bool, actual, expect any, message .
 // always return false if the value is a bool, an integer, a floating number, a complex, or a
 // string.
 func (a *Assertion) Nil(val any, message ...string) error {
+	a.Helper()
+
 	return tryNil(a.T, false, val, message...)
 }
 
@@ -69,13 +83,17 @@ func (a *Assertion) Nil(val any, message ...string) error {
 //
 // 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 {
+	a.Helper()
+
 	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 {
+	a.Helper()
+
 	return tryNotNil(a.T, false, val, message...)
 }
 
@@ -85,11 +103,15 @@ func (a *Assertion) NotNil(val any, message ...string) error {
 //
 // 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 {
+	a.Helper()
+
 	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 {
+	t.Helper()
+
 	if isNil(val) {
 		return nil
 	}
@@ -102,6 +124,8 @@ func tryNil(t *testing.T, failedNow bool, val any, message ...string) error {
 
 // 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
 	}

panic.go

@@ -8,30 +8,40 @@ import (
 // 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 {
+	a.Helper()
+
 	return tryPanic(a.T, false, fn, message...)
 }
 
 // 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 {
+	a.Helper()
+
 	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 {
+	a.Helper()
+
 	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 {
+	a.Helper()
+
 	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 {
+	t.Helper()
+
 	e := isPanic(fn)
 	if e != nil {
 		return nil
@@ -46,6 +56,8 @@ func tryPanic(t *testing.T, failedNow bool, fn func(), message ...string) error
 // tryNotPanic executes the function fn, and try to catching the panic error. It expect the
 // function fn does not to panic, and returns error if panic.
 func tryNotPanic(t *testing.T, failedNow bool, fn func(), message ...string) error {
+	t.Helper()
+
 	e := isPanic(fn)
 	if e == nil {
 		return nil

util.go

@@ -9,14 +9,16 @@ import (
 // marks the function has failed if the err is not nil. It'll also stops the execution if failedNow
 // set to true.
 func failed(t *testing.T, err error, failedNow bool) {
+	t.Helper()
+
 	if err == nil {
 		return
 	}
 
+	t.Error(err)
+
 	if failedNow {
-		t.Fatal(err)
-	} else {
-		t.Error(err)
+		t.FailNow()
 	}
 }