@Test
  fun testNoUncompress() {
    val response = response("https://httpbin.org/brotli", "XXXX".encodeUtf8())

    val same = brotliInterceptor.decompress(response)

    val responseString = same.body.string()
    assertThat(responseString).isEqualTo("XXXX")
  }

  @Test
  fun testFailsUncompress() {
    val response =
      response("https://httpbin.org/brotli", "bb919aaa06e8".decodeHex()) {
        header("Content-Encoding", "br")

import org.junit.jupiter.api.Test
import org.junit.jupiter.api.extension.RegisterExtension

class InsecureForHostTest {
  @RegisterExtension @JvmField
  val platform = PlatformRule()

  @RegisterExtension @JvmField
  val clientTestRule = OkHttpClientTestRule()

  @StartStop
  private val server = MockWebServer()

  @BeforeEach
  fun setup() {
    // BCX509ExtendedTrustManager not supported in TlsUtil.newTrustManager

@Suppress("NAME_SHADOWING")
class MultipartBody internal constructor(
  private val boundaryByteString: ByteString,
  @get:JvmName("type") val type: MediaType,
  @get:JvmName("parts") val parts: List<Part>,
) : RequestBody() {
  private val contentType: MediaType = "$type; boundary=$boundary".toMediaType()
  private var contentLength = -1L

  @get:JvmName("boundary")
  val boundary: String
    get() = boundaryByteString.utf8()

    server.enqueue(MockResponse(body = "abc"))
    server.enqueue(MockResponse(body = "def"))

    val request = Request(server.url("/"))

    val call = client.newCall(request)
    val response1 = call.execute()

    val cloned = call.clone()
    val response2 = cloned.execute()

    assertThat("abc").isEqualTo(response1.body.string())
    assertThat("def").isEqualTo(response2.body.string())
  }

    ) {
      if (random != null) {
        val sslSocket = connection.socket() as SSLSocket
        val session = sslSocket.session

        val masterSecretHex =
          session.masterSecret
            ?.encoded
            ?.toByteString()
            ?.hex()

        if (masterSecretHex != null) {
          val keyLog = "CLIENT_RANDOM $random $masterSecretHex"

          if (verbose) {

    override val timestampNs: Long,
    override val call: Call,
    val domainName: String,
    val inetAddressList: List<InetAddress>,
  ) : CallEvent() {
    override fun closes(event: CallEvent): Boolean = event is DnsStart && call == event.call && domainName == event.domainName
  }

  data class ConnectStart(
    override val timestampNs: Long,
    override val call: Call,
    val inetSocketAddress: InetSocketAddress,
    val proxy: Proxy?,

  public val failHandshake: Boolean
  public val onRequestStart: SocketEffect?
  public val doNotReadRequestBody: Boolean
  public val onRequestBody: SocketEffect?
  public val onResponseStart: SocketEffect?
  public val onResponseBody: SocketEffect?
  public val onResponseEnd: SocketEffect?
  public val shutdownServer: Boolean

  public val headersDelayNanos: Long
  public val bodyDelayNanos: Long
  public val trailersDelayNanos: Long

    //     timeout is hit we like to tear down the whole stream.

    private const val SOURCE_UPSTREAM = 1
    private const val SOURCE_FILE = 2

    @JvmField val PREFIX_CLEAN = "OkHttp cache v1\n".encodeUtf8()

    @JvmField val PREFIX_DIRTY = "OkHttp DIRTY :(\n".encodeUtf8()
    private const val FILE_HEADER_SIZE = 32L

    /**

					Expression: clause.Expr{SQL: "FIELD(id, ?)", Vars: []interface{}{[]int{1, 2, 3}}, WithoutParentheses: true},
				},
			},
			"SELECT * FROM `users` ORDER BY FIELD(id, ?,?,?)",
			[]interface{}{1, 2, 3},
		},
	}

	for idx, result := range results {
		t.Run(fmt.Sprintf("case #%v", idx), func(t *testing.T) {
			checkBuildClauses(t, result.Clauses, result.Result, result.Vars)
		})
	}

  @RegisterExtension
  val platform = PlatformRule()

  @RegisterExtension
  val clientTestRule = OkHttpClientTestRule()

  @StartStop
  val server1 = MockWebServer()

  @StartStop
  val server2 = MockWebServer()

  private var listener = RecordingEventListener()

  private val handshakeCertificates = platform.localhostHandshakeCertificates()

  val dns = FakeDns()