handler.ServeHTTP(w, req)
			return
		}

		req = req.WithContext(WithTask(ctx, &Task{}))
		panicCh := make(chan any, 1)
		go func() {
			defer func() {
				if r := recover(); r != nil {
					panicCh <- r
				}
				close(panicCh)
			}()
			handler.ServeHTTP(w, req)
		}()

		if p, ok := <-panicCh; ok {
			panic(p)
		}

		ctx = req.Context()
		if t := TaskFrom(ctx); t != nil && t.Func != nil {
			t.Func()

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
			//

		{
			desc:  "Issue 48502: call runtime.Goexit in t.Cleanup after panic",
			flags: []string{"-test.run=^TestGoexitInCleanupAfterPanicHelper$"},
			want: `panic: die
	panic: test executed panic(nil) or runtime.Goexit`,
		},
		{
			desc:  "Issue 48515: call t.Run in t.Cleanup should trigger panic",
			flags: []string{"-test.run=^TestCallRunInCleanupHelper$"},
			want:  `panic: testing: t.Run called during t.Cleanup`,
		},
	}

func (r *result) Return() (runtime.Object, error) {
	switch {
	case r.reason != nil:
		// panic has higher precedence, the goroutine executing ResultFunc has panic'd,
		// so propagate a panic to the caller.
		panic(r.reason)
	case r.err != nil:
		return nil, r.err
	default:
		// if we are here, it means neither a panic, nor an error
		if status, ok := r.object.(*metav1.Status); ok {

	b, err := ParseBase(s)
	if err != nil {
		panic(err)
	}
	return b
}

// MustParseScript is like ParseScript, but panics if the given script cannot be
// parsed. It simplifies safe initialization of Script values.
func MustParseScript(s string) Script {
	scr, err := ParseScript(s)
	if err != nil {
		panic(err)
	}
	return scr
}

// MustParseRegion is like ParseRegion, but panics if the given region cannot be