feat: add PanicOf.

Author: ghosind

builtin.go

@@ -831,6 +831,13 @@ func NotPanicNow(t *testing.T, fn func(), message ...any) error {
 	return tryNotPanic(t, true, fn, message...)
 }
 
+// PanicOf expects the function fn to panic by the expected error.
+func PanicOf(t *testing.T, fn func(), expectErr any, message ...any) error {
+	t.Helper()
+
+	return tryPanicOf(t, false, fn, expectErr, message...)
+}
+
 // True tests whether a value is truthy or not. It'll set the result to fail if the value is a
 // false value. For most types of value, a falsy value is the zero value for its type. For a
 // slice, a truthy value should not be nil, and its length must be greater than 0. For nil, the

error.go

@@ -22,6 +22,7 @@ const (
 	defaultErrMessageNotNil             string = "expect not nil, got nil"
 	defaultErrMessagePanic              string = "missing expected panic"
 	defaultErrMessageNotPanic           string = "got unwanted error: %v"
+	defaultErrMessagePanicOf            string = "expect panic by %v, got %v"
 	defaultErrMessageTrue               string = "the expression evaluated to a falsy value"
 	defaultErrMessageNotTrue            string = "the expression evaluated to a truthy value"
 	defaultErrMessageMapHasKey          string = "expect map has key %v"

panic.go

@@ -102,6 +102,28 @@ func tryNotPanic(t *testing.T, failedNow bool, fn func(), message ...any) error
 	return err
 }
 
+// PanicOf expects the function fn to panic by the expected error.
+func (a *Assertion) PanicOf(fn func(), expectErr any, message ...any) error {
+	a.Helper()
+
+	return tryPanicOf(a.T, false, fn, expectErr, message...)
+}
+
+// tryPanicOf executes the function fn, and it expects the function to panic by the expected error.
+func tryPanicOf(t *testing.T, failedNow bool, fn func(), expectError any, message ...any) error {
+	t.Helper()
+
+	e := isPanic(fn)
+	if isEqual(e, expectError) {
+		return nil
+	}
+
+	err := newAssertionError(fmt.Sprintf(defaultErrMessagePanicOf, expectError, e))
+	failed(t, err, failedNow)
+
+	return err
+}
+
 // isPanic executes the function, and tries to catching and returns the return value from
 // recover().
 func isPanic(fn func()) (err any) {

panic_test.go

@@ -1,6 +1,7 @@
 package assert
 
 import (
+	"errors"
 	"testing"
 )
 
@@ -52,6 +53,32 @@ func testPanicAndNotPanic(a, mockA *Assertion, fn func(), isPanic bool) {
 	}, isPanic)
 }
 
+func TestPanicOf(t *testing.T) {
+	a := New(t)
+	mockA := New(new(testing.T))
+
+	expectedErr := errors.New("expected error")
+
+	testPanicOf(a, mockA, func() {}, expectedErr, false)
+	testPanicOf(a, mockA, func() {
+		panic(expectedErr)
+	}, expectedErr, true)
+	testPanicOf(a, mockA, func() {
+		panic("not expected error")
+	}, expectedErr, false)
+}
+
+func testPanicOf(a, mockA *Assertion, fn func(), expectErr any, isExpectedPanic bool) {
+	a.Helper()
+
+	testAssertionFunction(a, "PanicOf", func() error {
+		return PanicOf(mockA.T, fn, expectErr)
+	}, isExpectedPanic)
+	testAssertionFunction(a, "Assertion.PanicOf", func() error {
+		return mockA.PanicOf(fn, expectErr)
+	}, isExpectedPanic)
+}
+
 func TestIsPanic(t *testing.T) {
 	Nil(t, isPanic(func() {
 		// no panic