}

    fun processNextFrame(): Boolean {
      taskFaker.runTasks()
      return webSocket!!.processNextFrame()
    }

    override fun close() {
      if (closed) {
        throw AssertionError("Already closed")
      }
      try {
        source.close()
      } catch (ignored: IOException) {
      }
      try {
        sink.close()
      } catch (ignored: IOException) {
      }

        if (streamsToClose != null) {
          listener.onClosed(this, receivedCloseCode, receivedCloseReason!!)
        }
      } else {
        throw AssertionError()
      }

      return true
    } finally {
      writerToClose?.closeQuietly()
      streamsToClose?.closeQuietly()
    }
  }

  internal fun writePingFrame() {

            // and resetting the stream.
            duplexResponseSent.await()
          } catch (e: InterruptedException) {
            throw AssertionError()
          }
          super.responseHeadersEnd(call, response)
        }
      }
    client =
      client.newBuilder()
        .eventListener(listener)
        .build()
    val body =

        ) {
          try {
            // Wait for request2 to guarantee we make 2 separate connections to the server.
            latch1.await()
          } catch (e: InterruptedException) {
            throw AssertionError(e)
          }
        }

        override fun connectionAcquired(
          call: Call,
          connection: Connection,
        ) {

        responses.offer(response!!.body.string())
        try {
          latch.await()
        } catch (e: InterruptedException) {
          throw AssertionError()
        }
        response.request
      }
    val blockingAuthClient =
      client.newBuilder()
        .authenticator(authenticator)
        .build()
    val callback: Callback =

  }

  fun takeAll(): List<String> {
    val list = mutableListOf<String>()
    logs.drainTo(list)
    return list
  }

  fun take(): String {
    return logs.poll(10, TimeUnit.SECONDS)
      ?: throw AssertionError("Timed out waiting for log message.")
  }

          findByIssuerAndSignatureMethod.invoke(
            trustManager,
            cert,
          ) as TrustAnchor
        trustAnchor.trustedCert
      } catch (e: IllegalAccessException) {
        throw AssertionError("unable to get issues and signature", e)
      } catch (_: InvocationTargetException) {
        null
      }
    }
  }

  companion object {
    val isSupported: Boolean =
      when {

          path = requestHeaders.value(i)
          break
        }
        i++
      }
      if (path == null) {
        // TODO: send bad request error
        throw AssertionError()
      }
      val file = File(baseDirectory.toString() + path)
      if (file.isDirectory) {
        serveDirectory(stream, file.listFiles()!!)
      } else if (file.exists()) {
        serveFile(stream, file)

    // Confirm the interceptor isn't exercised.
    client =
      client.newBuilder()
        .addNetworkInterceptor(Interceptor { chain: Interceptor.Chain? -> throw AssertionError() })
        .build()
    assertThat(get(url).body.string()).isEqualTo("A")
  }

  @Test
  fun iterateCache() {
    // Put some responses in the cache.
    server.enqueue(

      byteCount: Int,
      last: Boolean,
    ): Boolean {
      events.add(AssertionError("onData"))
      notifyAll()
      return false
    }

    @Synchronized override fun onReset(
      streamId: Int,
      errorCode: ErrorCode,
    ) {
      events.add(AssertionError("onReset"))
      notifyAll()
    }
  }

  companion object {
    fun roundUp(