refactor: add failed handler and try functions.

Author: ghosind

assertion.go

@@ -21,44 +21,6 @@ func New(t *testing.T) *Assertion {
 	return a
 }
 
-// #########################
-// ## Assertion Functions ##
-// #########################
-
-// DeepEqual tests deeply equality between actual and expect parameters.
-func (a *Assertion) DeepEqual(actual, expect any, message ...string) error {
-	return DeepEqual(a.t, actual, expect, message...)
-}
-
-// NotDeepEqual tests deeply inequality between actual and expected parameters.
-func (a *Assertion) NotDeepEqual(actual, expect any, message ...string) error {
-	return NotDeepEqual(a.t, 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 (a *Assertion) Nil(val any, message ...string) error {
-	return Nil(a.t, 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 NotNil(a.t, val, message...)
-}
-
-// Panic expects the function fn to panic.
-func (a *Assertion) Panic(fn func(), message ...string) (err error) {
-	return Panic(a.t, fn, message...)
-}
-
-// NotPanic asserts that the function fn does not panic.
-func (a *Assertion) NotPanic(fn func(), message ...string) (err error) {
-	return NotPanic(a.t, fn, message...)
-}
-
 // ##########################
 // ## Delegation Functions ##
 // ##########################

builtin.go

@@ -0,0 +1,39 @@
+package assert
+
+import (
+	"testing"
+)
+
+// DeepEqual tests deeply equality between actual and expect parameters.
+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.
+func NotDeepEqual(t *testing.T, actual, expect any, message ...string) error {
+	return tryNotDeepEqual(t, false, 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...)
+}
+
+// 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.
+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.
+func NotPanic(t *testing.T, fn func(), message ...string) error {
+	return tryNotPanic(t, false, fn, message...)
+}

equal.go

@@ -7,57 +7,75 @@ import (
 )
 
 // DeepEqual tests deeply equality between actual and expect parameters.
-func DeepEqual(t *testing.T, actual, expect any, message ...string) error {
+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.
+func (a *Assertion) NotDeepEqual(actual, expect any, message ...string) error {
+	return tryNotDeepEqual(a.t, false, 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 {
 	if reflect.DeepEqual(actual, expect) {
 		return nil
 	}
 
 	err := newAssertionError(fmt.Sprintf("%v == %v", actual, expect), message...)
-
-	t.Error(err)
+	failed(t, err, failedNow)
 
 	return err
 }
 
-// NotDeepEqual tests deeply inequality between actual and expected parameters.
-func NotDeepEqual(t *testing.T, actual, expect any, message ...string) error {
+// 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 {
 	if !reflect.DeepEqual(actual, expect) {
 		return nil
 	}
 
 	err := newAssertionError(fmt.Sprintf("%v != %v", actual, expect), message...)
-
-	t.Error(err)
+	failed(t, err, failedNow)
 
 	return err
 }
 
 // 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 {
+func (a *Assertion) Nil(val any, message ...string) error {
+	return tryNil(a.t, false, 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...)
+}
+
+// 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) {
 		return nil
 	}
 
 	err := newAssertionError(fmt.Sprintf("expect nil, got %v", val), message...)
-
-	t.Error(err)
+	failed(t, err, failedNow)
 
 	return err
 }
 
-// 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 {
+// 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 {
 	if !isNil(val) {
 		return nil
 	}
 
 	err := newAssertionError("expect not nil, got nil", message...)
-
-	t.Error(err)
+	failed(t, err, failedNow)
 
 	return err
 }

panic.go

@@ -6,27 +6,38 @@ import (
 )
 
 // Panic expects the function fn to panic.
-func Panic(t *testing.T, fn func(), message ...string) (err error) {
-	defer func() {
-		if e := recover(); e == nil {
-			err = newAssertionError("mssing expected panic", message...)
-		}
-	}()
-
-	fn()
-
-	return
+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.
-func NotPanic(t *testing.T, fn func(), message ...string) (err error) {
-	defer func() {
-		if e := recover(); e != nil {
-			err = newAssertionError(fmt.Sprintf("got unwanted error: %v", e), message...)
-		}
-	}()
+func (a *Assertion) NotPanic(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 {
+	e := isPanic(fn)
+	if e != nil {
+		return nil
+	}
+
+	err := newAssertionError("missing expected panic", message...)
+	failed(t, err, failedNow)
+
+	return err
+}
 
-	fn()
+// 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 {
+	e := isPanic(fn)
+	if e == nil {
+		return nil
+	}
 
-	return
+	err := newAssertionError(fmt.Sprintf("got unwanted error: %v", e), message...)
+	failed(t, err, failedNow)
+	return err
 }

util.go

@@ -1,6 +1,28 @@
 package assert
 
-import "reflect"
+import (
+	"reflect"
+	"testing"
+)
+
+// failed handles the assertion error with the specific testing.T or the assertion's t. It will set
+// 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) {
+	if err == nil {
+		return
+	}
+
+	if failedNow {
+		t.Fatal(err)
+	} else {
+		t.Error(err)
+	}
+}
+
+// ################################
+// ## Assertion Helper Functions ##
+// ################################
 
 // isNil checks whether a value is nil or not. It'll always return false if the value is not a
 // channel, a function, a map, a point, an unsafe point, an interface, or a slice.
@@ -19,3 +41,17 @@ func isNil(val any) bool {
 		return false
 	}
 }
+
+// isPanic executes the function, and tries to catching and returns the return value from
+// recover().
+func isPanic(fn func()) (err any) {
+	defer func() {
+		if e := recover(); e != nil {
+			err = e
+		}
+	}()
+
+	fn()
+
+	return
+}

util_test.go

@@ -12,3 +12,12 @@ func TestIsNil(t *testing.T) {
 	assert.DeepEqual(isNil(testAssert), true)
 	assert.DeepEqual(isNil(assert), false)
 }
+
+func TestIsPanic(t *testing.T) {
+	Nil(t, isPanic(func() {
+		// no panic
+	}))
+	NotNil(t, isPanic(func() {
+		panic("unexpected panic")
+	}))
+}