}

  @Test
  fun clientReadsHeadersDataTrailersHttp2() {
    platform.assumeHttp2Support()
    server.enqueue(
      MockResponse.Builder()
        .clearHeaders()
        .addHeader("h1", "v1")
        .addHeader("h2", "v2")
        .body("HelloBonjour")
        .trailers(headersOf("trailers", "boom"))
        .build(),
    )

                // to
                // ensure that the thread running the failure callbacks is not the main thread.
                Uninterruptibles.awaitUninterruptibly(afterStarted);
                notifyFailed(new Exception("boom"));
              }
            }.start();
          }

          @Override
          protected void doStop() {
            notifyStopped();
          }
        };

                // to
                // ensure that the thread running the failure callbacks is not the main thread.
                Uninterruptibles.awaitUninterruptibly(afterStarted);
                notifyFailed(new Exception("boom"));
              }
            }.start();
          }

          @Override
          protected void doStop() {
            notifyStopped();
          }
        };

    Exception::class,
  )
  fun throwingOnFailLogs() {
    webServer.enqueue(
      MockResponse.Builder()
        .code(200)
        .body("Body")
        .build(),
    )
    val e = RuntimeException("boom")
    clientListener.setNextEventDelegate(
      object : WebSocketListener() {
        override fun onFailure(
          webSocket: WebSocket,
          t: Throwable,
          response: Response?,
        ) {

func TestCgoExternalThreadPanic(t *testing.T) {
	t.Parallel()
	if runtime.GOOS == "plan9" {
		t.Skipf("no pthreads on %s", runtime.GOOS)
	}
	got := runTestProg(t, "testprogcgo", "CgoExternalThreadPanic")
	want := "panic: BOOM"
	if !strings.Contains(got, want) {
		t.Fatalf("want failure containing %q. output:\n%s\n", want, got)
	}
}

func TestCgoExternalThreadSIGPROF(t *testing.T) {
	t.Parallel()
	// issue 9456.

		}
	}
}

func TestInterruptWithPanic(t *testing.T) {
	run(t, func(t *testing.T, mode testMode) {
		t.Run("boom", func(t *testing.T) { testInterruptWithPanic(t, mode, "boom") })
		t.Run("nil", func(t *testing.T) { t.Setenv("GODEBUG", "panicnil=1"); testInterruptWithPanic(t, mode, nil) })

        @OutputFiles
        FileCollection getOutputFiles() {
            throw new Exception("BOOM!")
        }
    }

    static class FailingTask extends DefaultTask {
        @TaskAction
        void execute() {
            throw new RuntimeException("BOOM!")
        }
    }

    /**
     * Asserts there is a task ready to run, and runs it.
     */

	"book":                                 "\U0001f4d6",
	"bookmark":                             "\U0001f516",
	"bookmark_tabs":                        "\U0001f4d1",
	"books":                                "\U0001f4da",
	"boom":                                 "\U0001f4a5",
	"boomerang":                            "\U0001fa83",
	"boot":                                 "\U0001f462",
	"bosnia_herzegovina":                   "\U0001f1e7\U0001f1e6",

    client =
      client.newBuilder()
        .dns { hostname: String? -> throw RuntimeException("boom!") }
        .build()
    server.enqueue(MockResponse())
    assertFailsWith<RuntimeException> {
      getResponse(newRequest("/"))
    }.also { expected ->
      assertThat(expected.message).isEqualTo("boom!")
    }
  }

  @Test
  fun streamedBodyIsRetriedOnHttp2Shutdown() {

		// The code we add here clobbers parts of the stack in the child.
		// When the parent resumes, it is using the same stack frame. But the
		// child has clobbered stack variables that the parent needs. Boom!
		// In particular, the sys argument gets clobbered.
		return
	}
	if lv.f.Name == "wbBufFlush" ||
		((lv.f.Name == "callReflect" || lv.f.Name == "callMethod") && lv.fn.ABIWrapper()) {