containing an IP address we must match that address against the URL's IP address, even when the
    two addresses are encoded differently, such as `192.168.1.1` and `0::0:0:FFFF:C0A8:101`. Note
    that OkHttp incorrectly rejected valid certificates resulting in a failure to connect; at no
    point were invalid certificates accepted.

    assertThat(parse("http://[0:a:b:c:d:e:f:1]/").host).isEqualTo("0:a:b:c:d:e:f:1")
    assertThat(parse("http://[a:b:c:d:e:f:1:0]/").host).isEqualTo("a:b:c:d:e:f:1:0")
    assertThat(parse("http://[FF01:0:0:0:0:0:0:101]/").host).isEqualTo("ff01::101")
    assertThat(parse("http://[2001:db8::1]/").host).isEqualTo("2001:db8::1")
    assertThat(parse("http://[2001:db8:0:0:0:0:2:1]/").host).isEqualTo("2001:db8::2:1")

    // http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html

    // We can't test 100 because it's not really a response.
    // assertCached(false, 100);
    assertCached(false, 101)
    assertCached(true, 200)
    assertCached(false, 201)
    assertCached(false, 202)
    assertCached(true, 203)
    assertCached(true, 204)
    assertCached(false, 205)

  @Test
  fun windowUpdateFrames() {
    assertThat(frameLogWindowUpdate(false, 0, 4, Int.MAX_VALUE.toLong()))
      .isEqualTo(">> 0x00000000     4 WINDOW_UPDATE 2147483647")
    assertThat(frameLogWindowUpdate(true, 101, 4, 1))
      .isEqualTo("<< 0x00000065     4 WINDOW_UPDATE 1")
  }

  @Test
  fun flagOverlapOn0x1() {
    assertThat(frameLog(true, 0, 0, TYPE_SETTINGS, 0x1))
      .isEqualTo("<< 0x00000000     0 SETTINGS      ACK")

    clientListener.assertFailure(
      101,
      null,
      ProtocolException::class.java,
      "Expected 'Connection' header value 'Upgrade' but was 'null'",
    )
    webSocket.cancel()
  }

  @Test
  @Throws(IOException::class)
  fun wrongConnectionHeader() {
    webServer.enqueue(
      MockResponse.Builder()
        .code(101)
        .setHeader("Upgrade", "websocket")

          }
        },
      )
        .setPriority(REQUEST_PRIORITY_MEDIUM)
        .setDirectExecutorAllowed(true)
        .setTrafficStatsTag(101)
        .build()

    req.start()
    return completableFuture
  }

  @Test
  fun urlConnection() {
    val conn = engine.openConnection(URL("https://google.com/robots.txt")) as HttpURLConnection

  )

  internal class Failure(
    val t: Throwable,
    val response: Response?,
  ) {
    val responseBody: String? =
      when {
        response != null && response.code != 101 -> response.body.string()
        else -> null
      }

    override fun toString(): String {
      return when (response) {
        null -> "Failure[$t]"
        else -> "Failure[$response]"
      }

            .build()
        code = response.code
      }

      exchange.responseHeadersEnd(response)

      response =
        if (forWebSocket && code == 101) {
          // Connection is upgrading, but we need to ensure interceptors see a non-null response body.
          response.stripBody()
        } else {
          response.newBuilder()

    ).isEqualTo("1080::8:800:200c:417a")

    assertThat("1080::8:800:200C:417A".toCanonicalHost()).isEqualTo("1080::8:800:200c:417a")
    assertThat("FF01::101".toCanonicalHost()).isEqualTo("ff01::101")
    assertThat(
      "0:0:0:0:0:FFFF:129.144.52.38".toCanonicalHost(),
    ).isEqualTo("129.144.52.38")

    assertThat("::FFFF:129.144.52.38".toCanonicalHost()).isEqualTo("129.144.52.38")

    return true
  }

  @Throws(IOException::class)
  internal fun checkUpgradeSuccess(
    response: Response,
    exchange: Exchange?,
  ) {
    if (response.code != 101) {
      throw ProtocolException(
        "Expected HTTP 101 response but was '${response.code} ${response.message}'",
      )
    }

    val headerConnection = response.header("Connection")