* exception goes to the uncaught exception handler.
   */
  private fun interceptorThrowsRuntimeExceptionAsynchronous(network: Boolean) {
    val boom = RuntimeException("boom!")
    addInterceptor(network) { chain: Interceptor.Chain? -> throw boom }
    val executor = ExceptionCatchingExecutor()
    client =
      client
        .newBuilder()
        .dispatcher(Dispatcher(executor))
        .build()

    val requestBody =
      object : RequestBody() {
        override fun contentType(): MediaType? = null

        override fun writeTo(sink: BufferedSink) {
          throw IOException("boom") // Despite this exception, 'sink' is healthy.
        }
      }

    val callA =
      client.newCall(
        Request(
          url = server.url("/"),
          body = requestBody,
        ),

   * array, it is returned therein. Otherwise, a new array is allocated with the runtime type of the
   * specified array and the size of the specified collection.
   *
   * <p>If the collection fits in the specified array with room to spare (i.e., the array has more
   * elements than the collection), the element in the array immediately following the end of the
   * collection is set to {@code null}. This is useful in determining the length of the collection

   * array, it is returned therein. Otherwise, a new array is allocated with the runtime type of the
   * specified array and the size of the specified collection.
   *
   * <p>If the collection fits in the specified array with room to spare (i.e., the array has more
   * elements than the collection), the element in the array immediately following the end of the
   * collection is set to {@code null}. This is useful in determining the length of the collection

        SearchLogHelper mockSearchLogHelper = new SearchLogHelper() {
            @Override
            public void storeSearchLog() {
                throw new OutOfMemoryError("Simulated OOM");
            }
        };
        ComponentUtil.register(mockSearchLogHelper, "searchLogHelper");

        // Execute the job - Error should NOT be caught since implementation only catches Exception
        try {

        .exhaustResponse()
    server.enqueue(
      MockResponse
        .Builder()
        .clearHeaders()
        .addHeader("h1", "v1")
        .addHeader("h2", "v2")
        .trailers(headersOf("trailers", "boom"))
        .socketHandler(body)
        .build(),
    )
    val call =
      client.newCall(
        Request
          .Builder()
          .url(server.url("/"))
          .build(),
      )

    }
  }

  tasks.withType<Test> {
    useJUnitPlatform()
    jvmArgs(
      "-Dokhttp.platform=$platform",
    )

    if (platform == "loom") {
      jvmArgs(
        "-Djdk.tracePinnedThreads=short",
      )
    }

    val javaToolchains = project.extensions.getByType<JavaToolchainService>()
    javaLauncher.set(javaToolchains.launcherFor {

labels.homePhone=Home Phone
labels.user_homePostalAddress=Home Postal Address
labels.homePostalAddress=Home Postal Address
labels.user_labeledURI=labeledURI
labels.labeledURI=labeledURI
labels.user_roomNumber=Room Number
labels.roomNumber=Room Number
labels.user_description=Description
labels.description=Description
labels.user_title=Title
labels.title=Title
labels.user_pager=Pager
labels.pager=Pager
labels.user_street=Street

   * @param offset the start offset in the data
   * @param maxLength the maximum number of bytes to write
   * @return the number of bytes written to {@code dest}
   * @throws IndexOutOfBoundsException if there is not enough room in {@code dest}
   */
  @CanIgnoreReturnValue
  public int writeBytesTo(byte[] dest, int offset, int maxLength) {
    maxLength = min(maxLength, bits() / 8);

    peer.acceptFrame() // SYN_STREAM
    peer.sendFrame().headers(false, 3, headerEntries("headers", "bam"))
    peer.acceptFrame() // PING
    peer.sendFrame().headers(true, 3, headerEntries("trailers", "boom"))
    peer.sendFrame().ping(true, Http2Connection.AWAIT_PING, 0) // PONG
    peer.play()

    // Play it back.
    val connection = connect(peer)