feat: add notIsError.

Signed-off-by: ghosind <ghosind@gmail.com>

Author: ghosind

builtin.go

@@ -499,12 +499,14 @@ func NotHasSuffixStringNow(t *testing.T, str, suffix string, message ...any) err
 //
 //	err1 := errors.New("error 1")
 //	err2 := errors.New("error 2")
+//	err3 := errors.New("error 3")
 //	assert.IsError(t, err1, err1) // success
 //	assert.IsError(t, err1, err2) // fail
 //	assert.IsError(t, errors.Join(err1, err2), err1) // success
 //	assert.IsError(t, errors.Join(err1, err2), err2) // success
-func IsError(t *testing.T, err, target error, message ...any) error {
-	return isError(t, false, err, target, message...)
+//	assert.IsError(t, errors.Join(err1, err2), err3) // fail
+func IsError(t *testing.T, err, expected error, message ...any) error {
+	return isError(t, false, err, expected, message...)
 }
 
 // IsErrorNow tests whether the error matches the target or not. It'll set the result to fail and
@@ -517,8 +519,37 @@ func IsError(t *testing.T, err, target error, message ...any) error {
 //	assert.IsErrorNow(t, err1, err1) // success
 //	assert.IsErrorNow(t, err1, err2) // fail
 //	// never runs
-func IsErrorNow(t *testing.T, err, target error, message ...any) error {
-	return isError(t, true, err, target, message...)
+func IsErrorNow(t *testing.T, err, expected error, message ...any) error {
+	return isError(t, true, err, expected, message...)
+}
+
+// NotIsError tests whether the error matches the target or not. It'll set the result to fail if
+// the error matches to the target error, and it doesn't stop the execution.
+//
+//	err1 := errors.New("error 1")
+//	err2 := errors.New("error 2")
+//	err3 := errors.New("error 3")
+//	assert.NotIsError(t, err1, err2) // success
+//	assert.NotIsError(t, err1, err1) // fail
+//	assert.NotIsError(t, errors.Join(err1, err2), err3) // success
+//	assert.NotIsError(t, errors.Join(err1, err2), err1) // fail
+//	assert.NotIsError(t, errors.Join(err1, err2), err2) // fail
+func NotIsError(t *testing.T, err, unexpected error, message ...any) error {
+	return notIsError(t, false, err, unexpected, message...)
+}
+
+// NotIsErrorNow tests whether the error matches the target or not. It'll set the result to fail
+// and stop the execution if the error matches to the target error.
+//
+//	err1 := errors.New("error 1")
+//	err2 := errors.New("error 2")
+//	err3 := errors.new("error 3")
+//	assert.NotIsErrorNow(t, errors.Join(err1, err2), err3) // success
+//	assert.NotIsErrorNow(t, err1, err2) // fail
+//	assert.NotIsErrorNow(t, err1, err1) // fail and terminate
+//	// never runs
+func NotIsErrorNow(t *testing.T, err, unexpected error, message ...any) error {
+	return notIsError(t, true, err, unexpected, message...)
 }
 
 // MapHasKey tests whether the map contains the specified key or not, it will fail if the map does

error.go

@@ -35,6 +35,7 @@ const (
 	defaultErrMessageLt                 string = "%v must less then %v"
 	defaultErrMessageLte                string = "%v must less then or equal to %v"
 	defaultErrMessageIsError            string = "expect err matches %v, got %v"
+	defaultErrMessageNotIsError         string = "expect err does not matches %v"
 )
 
 var (

errors.go

@@ -16,8 +16,8 @@ import (
 //	a.IsError(err1, err2) // fail
 //	a.IsError(errors.Join(err1, err2), err1) // success
 //	a.IsError(errors.Join(err1, err2), err2) // success
-func (a *Assertion) IsError(err, target error, message ...any) error {
-	return isError(a.T, false, err, target, message...)
+func (a *Assertion) IsError(err, expected error, message ...any) error {
+	return isError(a.T, false, err, expected, message...)
 }
 
 // IsErrorNow tests whether the error matches the target or not. It'll set the result to fail and
@@ -31,19 +31,61 @@ func (a *Assertion) IsError(err, target error, message ...any) error {
 //	a.IsErrorNow(err1, err1) // success
 //	a.IsErrorNow(err1, err2) // fail
 //	// never runs
-func (a *Assertion) IsErrorNow(err, target error, message ...any) error {
-	return isError(a.T, true, err, target, message...)
+func (a *Assertion) IsErrorNow(err, expected error, message ...any) error {
+	return isError(a.T, true, err, expected, message...)
+}
+
+// NotIsError tests whether the error matches the target or not. It'll set the result to fail if
+// the error matches to the target error, and it doesn't stop the execution.
+//
+//	a := assert.New(t)
+//	err1 := errors.New("error 1")
+//	err2 := errors.New("error 2")
+//	err3 := errors.New("error 3")
+//	a.NotIsError(err1, err2) // success
+//	a.NotIsError(err1, err1) // fail
+//	a.NotIsError(errors.Join(err1, err2), err3) // success
+//	a.NotIsError(errors.Join(err1, err2), err1) // fail
+//	a.NotIsError(errors.Join(err1, err2), err2) // fail
+func (a *Assertion) NotIsError(err, unexpected error, message ...any) error {
+	return notIsError(a.T, false, err, unexpected, message...)
+}
+
+// NotIsErrorNow tests whether the error matches the target or not. It'll set the result to fail
+// and stop the execution if the error matches to the target error.
+//
+//	a := assert.New(t)
+//	err1 := errors.New("error 1")
+//	err2 := errors.New("error 2")
+//	err3 := errors.new("error 3")
+//	a.NotIsErrorNow(errors.Join(err1, err2), err3) // success
+//	a.NotIsErrorNow(err1, err2) // fail
+//	a.NotIsErrorNow(err1, err1) // fail and terminate
+//	// never runs
+func (a *Assertion) NotIsErrorNow(err, unexpected error, message ...any) error {
+	return notIsError(a.T, true, err, unexpected, message...)
 }
 
 // isError tests whether the error matches the target or not.
-func isError(t *testing.T, failedNow bool, err, target error, message ...any) error {
+func isError(t *testing.T, failedNow bool, err, expected error, message ...any) error {
 	t.Helper()
 
 	return test(
 		t,
-		func() bool { return errors.Is(err, target) },
+		func() bool { return errors.Is(err, expected) },
+		failedNow,
+		fmt.Sprintf(defaultErrMessageIsError, expected, err),
+		message...,
+	)
+}
+
+// isError tests whether the error does not match the target error or not.
+func notIsError(t *testing.T, failedNow bool, err, unexpected error, message ...any) error {
+	return test(
+		t,
+		func() bool { return !errors.Is(err, unexpected) },
 		failedNow,
-		fmt.Sprintf(defaultErrMessageIsError, target, err),
+		fmt.Sprintf(defaultErrMessageNotIsError, unexpected),
 		message...,
 	)
 }

errors_test.go

@@ -29,10 +29,24 @@ func testIsError(a, mockA *Assertion, err, target error, isError bool) {
 		return mockA.IsError(err, target)
 	}, isError)
 
+	testAssertionFunction(a, "NotIsError", func() error {
+		return NotIsError(mockA.T, err, target)
+	}, !isError)
+	testAssertionFunction(a, "Assertion.NotIsError", func() error {
+		return mockA.NotIsError(err, target)
+	}, !isError)
+
 	testAssertionNowFunction(a, "IsErrorNow", func() {
 		IsErrorNow(mockA.T, err, target)
 	}, !isError)
 	testAssertionNowFunction(a, "Assertion.IsErrorNow", func() {
 		mockA.IsErrorNow(err, target)
 	}, !isError)
+
+	testAssertionNowFunction(a, "NotIsErrorNow", func() {
+		NotIsErrorNow(mockA.T, err, target)
+	}, isError)
+	testAssertionNowFunction(a, "Assertion.NotIsErrorNow", func() {
+		mockA.NotIsErrorNow(err, target)
+	}, isError)
 }