}

    fun assertNoMoreLogs() {
      assertThat(logs.size, "More messages remain: ${logs.subList(index, logs.size)}")
        .isEqualTo(index)
    }

    override fun log(message: String) {
      logs.add(message)
    }
  }

  companion object {
    private val PLAIN = "text/plain; charset=utf-8".toMediaType()
  }

            if (verbose) {
              println(record.message)
              println(record.parameters[0])
            }

            // JSSE logs additional messages as parameters that are not referenced in the log message.
            val parameter = parameters[0] as String

            if (message == "Produced ClientHello handshake message") {

      val statusLine = StatusLine.parse(headersReader.readLine())

      val responseBuilder =
        Response.Builder()
          .protocol(statusLine.protocol)
          .code(statusLine.code)
          .message(statusLine.message)
          .headers(headersReader.readHeaders())
          .trailers { error("trailers not available") }

      return when {
        expectContinue && statusLine.code == HTTP_CONTINUE -> {
          null

    }.also { expected ->
      assertThat(expected.message).isEqualTo("Code must be in range [1000,5000): 98724976")
    }
  }

  @Test fun closeReservedThrows() {
    assertFailsWith<IllegalArgumentException> {
      clientWriter.writeClose(1005, "Hello".encodeUtf8())
    }.also { expected ->
      assertThat(expected.message).isEqualTo("Code 1005 is reserved and may not be used.")
    }
  }

    }

    fun interface Logger {
      fun log(message: String)

      companion object {
        /** A [Logger] defaults output appropriate for the current platform. */
        @JvmField
        val DEFAULT: Logger = DefaultLogger()

        private class DefaultLogger : Logger {
          override fun log(message: String) {
            Platform.get().log(message)
          }
        }
      }
    }

      fail<Any>()
    } catch (expected: IllegalArgumentException) {
      assertThat(expected.message).isEqualTo("string does not include a private key")
    }
    try {
      decode(pkcs8Pem)
      fail<Any>()
    } catch (expected: IllegalArgumentException) {
      assertThat(expected.message).isEqualTo("string does not include a certificate")
    }
    try {

     * deduped.
     *
     * TODO: See if duped headers should be preserved on decode and verify.
     */
    private fun assertSetEquals(
      message: String,
      expected: List<Header>,
      observed: List<Header>,
    ) {
      assertThat(LinkedHashSet(observed), message)
        .isEqualTo(LinkedHashSet(expected))
    }
  }

    connectTimeout: Int,
  ) {
    socket.connect(address, connectTimeout)
  }

  open fun log(
    message: String,
    level: Int = INFO,
    t: Throwable? = null,
  ) {
    val logLevel = if (level == WARN) Level.WARNING else Level.INFO
    logger.log(logLevel, message, t)
  }

  open fun isCleartextTrafficPermitted(hostname: String): Boolean = true

  /**

          return Buffer().writeUtf8("hello")
        }
      }
    assertFailsWith<IOException> {
      body.bytes()
    }.also { expected ->
      assertThat(expected.message).isEqualTo(
        "Content-Length (10) and stream length (5) disagree",
      )
    }
  }

  @Test
  fun bytesThrowsMoreThanIntMaxValue() {
    val body: ResponseBody =

        .writeByte(0b01111111)

    val derReader = DerReader(buffer)

    assertFailsWith<ProtocolException> {
      derReader.read("test") {}
    }.also { expected ->
      assertThat(expected.message).isEqualTo("invalid encoding for length")
    }
  }

  @Test fun `decode length not encoded in shortest form possible`() {
    val buffer =
      Buffer()
        .writeByte(0b00000010)