testCallersEqual(t, pcs, want)
	}()
	func() {
		defer func() {
			r := recover()
			if r != "panic2" {
				t.Fatalf("got %v, wanted %v", r, "panic2")
			}
		}()
		func() {
			defer func() {
				// Again, panic2 aborts/replaces panic1
				panic("panic2")
			}()
			panic("panic1")
		}()
	}()
}

func TestCallersNilPointerPanic(t *testing.T) {

		}
	}()
	defer func() {
		panic("panic2")
	}()
	panic("panic1")
}

// This tests that recover() does not succeed unless it is called directly from a
// defer function that is directly called by the panic.  Here, we first call it
// from a defer function that is created by the defer function called directly by
// the panic.  In
func TestRecoverMatching(t *testing.T) {
	defer func() {

	_ = new(f1 /* ERROR "not a type" */ ())
}

func panic1() {
	panic() // ERROR "not enough arguments"
	panic(1, 2) // ERROR "too many arguments"
	panic(0)
	panic("foo")
	panic(false)
	panic(1<<10)
	panic(1 << /* ERROR "constant shift overflow" */ 1000)
	_ = panic /* ERROR "used as value" */ (0)

	var s []byte
	panic(s)
	panic(s... /* ERROR "invalid use of ..." */ )
}

func panic2() {

// This is used to try hard to get a panic stack trace out when exiting.
var runningPanicDefers atomic.Uint32

// panicking is non-zero when crashing the program for an unrecovered panic.
var panicking atomic.Uint32

// paniclk is held while printing the panic information and stack trace,
// so that two concurrent panics don't overlap their output.
var paniclk mutex

func goPanicExtendIndex(hi int, lo uint, y int) {
	panicCheck1(getcallerpc(), "index out of range")
	panic(boundsError{x: int64(hi)<<32 + int64(lo), signed: true, y: y, code: boundsIndex})
}
func goPanicExtendIndexU(hi uint, lo uint, y int) {
	panicCheck1(getcallerpc(), "index out of range")
	panic(boundsError{x: int64(hi)<<32 + int64(lo), signed: false, y: y, code: boundsIndex})
}

{"Action":"output","Test":"TestPanic","Output":"panic(0x1110ea0, 0x116aea0)\n"}
{"Action":"output","Test":"TestPanic","Output":"\t/go/src/runtime/panic.go:679 +0x1b2\n"}
{"Action":"output","Test":"TestPanic","Output":"command-line-arguments.TestPanic(0xc000092100)\n"}
{"Action":"output","Test":"TestPanic","Output":"\ta_test.go:6 +0x39\n"}

--- FAIL: TestPanic (0.00s)
panic: oops [recovered]
	panic: oops

goroutine 7 [running]:
testing.tRunner.func1(0xc000092100)
	/go/src/testing/testing.go:874 +0x3a3
panic(0x1110ea0, 0x116aea0)
	/go/src/runtime/panic.go:679 +0x1b2
command-line-arguments.TestPanic(0xc000092100)
	a_test.go:6 +0x39
testing.tRunner(0xc000092100, 0x114f500)
	go/src/testing/testing.go:909 +0xc9
created by testing.(*T).Run
	go/src/testing/testing.go:960 +0x350

Cuong Manh Le <******@****.***> 1635360910 +0700

Cuong Manh Le <******@****.***> 1635360910 +0700

func WithPanicRecovery(handler http.Handler, resolver request.RequestInfoResolver) http.Handler {
	return withPanicRecovery(handler, func(w http.ResponseWriter, req *http.Request, err interface{}) {
		if err == http.ErrAbortHandler {
			// Honor the http.ErrAbortHandler sentinel panic value
			//