.addInterceptor { chain ->
          assertThat(chain.request().header("Accept-Encoding")).isNull()
          Response
            .Builder()
            .request(chain.request())
            .protocol(Protocol.HTTP_1_1)
            .code(200)
            .message("OK")
            .body("Hello".toResponseBody())
            .header("Content-Encoding", "piedpiper")
            .build()
        }.build()

   * must contain [Protocol.HTTP_1_1]. It must not contain null.
   *
   * This list is ignored when [negotiation is disabled][protocolNegotiationEnabled].
   */
  public var protocols: List<Protocol> = immutableListOf(Protocol.HTTP_2, Protocol.HTTP_1_1)
    set(value) {
      val protocolList = value.toImmutableList()

            assertThat(source.exhausted()).isTrue()
          }
        }
        socketHandler.awaitSuccess()
      }
  }

  @Test
  fun upgradeHttps() {
    enableTls(Protocol.HTTP_1_1)
    upgrade()
  }

  @Test
  fun upgradeRefusedByServer() {
    server.enqueue(MockResponse(body = "normal request"))
    val requestWithUpgrade =
      Request
        .Builder()

      } else {
        javaNetSocket = rawSocket
        protocol =
          when {
            Protocol.H2_PRIOR_KNOWLEDGE in route.address.protocols -> Protocol.H2_PRIOR_KNOWLEDGE
            else -> Protocol.HTTP_1_1
          }
      }

      val connection =
        RealConnection(
          taskRunner = taskRunner,
          connectionPool = connectionPool,
          route = route,

    server.useHttps(handshakeCertificates.sslSocketFactory())
    server.protocols =
      when {
        http2 -> listOf(Protocol.HTTP_2, Protocol.HTTP_1_1)
        else -> listOf(Protocol.HTTP_1_1)
      }
    server.enqueue(
      MockResponse
        .Builder()
        .inTunnel()
        .build(),
    )
    client =
      client
        .newBuilder()

   * [priorResponse] objects, which have its own [priorResponse].
   */
  @get:JvmName("request") val request: Request,
  /** Returns the HTTP protocol, such as [Protocol.HTTP_1_1] or [Protocol.HTTP_1_0]. */
  @get:JvmName("protocol") val protocol: Protocol,
  /** Returns the HTTP status message. */
  @get:JvmName("message") val message: String,
  /** Returns the HTTP status code. */

    assertThat(request.body?.utf8()).isEqualTo("request")
  }

  @Test
  fun testH2PriorKnowledgeServerFallback() {
    try {
      server.protocols = listOf(Protocol.H2_PRIOR_KNOWLEDGE, Protocol.HTTP_1_1)
      fail<Unit>()
    } catch (expected: IllegalArgumentException) {
      assertThat(expected.message).isEqualTo(
        "protocols containing h2_prior_knowledge cannot use other protocols: " +

        Response
          .Builder()
          .code(101)
          .message("OK")
          .request(Request.Builder().url(url).build())
          .headers(responseHeaders!!)
          .protocol(Protocol.HTTP_1_1)
          .build()
      webSocket =
        RealWebSocket(
          taskFaker.taskRunner,
          response.request,
          listener,
          random!!,
          pingIntervalMillis.toLong(),

    val request = Request.Builder().url(server.url("/").toString()).build()
    val response = client.newCall(request).execute()
    response.use {
      assertEquals(200, response.code)
      assertEquals(Protocol.HTTP_1_1, response.protocol)
    }
  }

  @Test
  fun testCustomTrustManagerWithAndroidCheck() {
    assumeNetwork()

    var withHostCalled = false
    var withoutHostCalled = false

      } catch (e: IOException) {
        failWebSocket(e = e, isWriter = true)
      }
      return -1L
    }
  }

  companion object {
    private val ONLY_HTTP1 = listOf(Protocol.HTTP_1_1)

    /**
     * The maximum number of bytes to enqueue. Rather than enqueueing beyond this limit we tear down
     * the web socket! It's possible that we're writing faster than the peer can read.
     */