}

    // Break apart the domain into UTF-8 labels, i.e. foo.bar.com turns into [foo, bar, com].
    val domainLabelsUtf8Bytes = Array(domainLabels.size) { i -> domainLabels[i].toByteArray() }

    // Start by looking for exact matches. We start at the leftmost label. For example, foo.bar.com
    // will look like: [foo, bar, com], [bar, com], [com]. The longest matching rule wins.
    var exactMatch: String? = null

  }

  @Test
  fun outOfOrderResponses() {
    val firstResponseCode = AtomicInteger()
    val secondResponseCode = AtomicInteger()
    val secondRequest = "/bar"
    val firstRequest = "/foo"
    val latch = CountDownLatch(1)
    val dispatcher: Dispatcher =
      object : Dispatcher() {
        override fun dispatch(request: RecordedRequest): MockResponse {
          if (request.path == firstRequest) {

      MockResponse.Builder()
        .code(HttpURLConnection.HTTP_MOVED_PERM)
        .addHeader("Location: /foo")
        .build(),
    )
    server.enqueue(
      MockResponse.Builder()
        .body("DEF")
        .build(),
    )
    val request1 = Request.Builder().url(server.url("/foo")).build()
    val response1 = client.newCall(request1).execute()
    assertThat(response1.body.string()).isEqualTo("ABC")

    assertThat(bodyAsString(body)).isEqualTo("foo")
  }

  @Test
  fun referer() {
    val request = fromArgs("-e", "foo", "http://example.com").createRequest()
    assertThat(request.method).isEqualTo("GET")
    assertThat(request.url.toString()).isEqualTo("http://example.com/")
    assertThat(request.header("Referer")).isEqualTo("foo")
    assertThat(request.body).isNull()
  }

  @Test

      .isEqualTo("example.com")
    assertThat(publicSuffixDatabase.getEffectiveTldPlusOne("foo.example.com"))
      .isEqualTo("example.com")
    assertThat(publicSuffixDatabase.getEffectiveTldPlusOne("foo.bar.square.com"))
      .isEqualTo("bar.square.com")
    assertThat(publicSuffixDatabase.getEffectiveTldPlusOne("foo.my.square.com"))
      .isEqualTo("foo.my.square.com")
  }

  @Test fun wildcardMatch() {
    val buffer =
      Buffer()

        )
        .hostnameVerifier(RecordingHostnameVerifier())
        .build()
    val response = getResponse(newRequest("/foo"))
    assertContent("this response comes via HTTPS", response)
    val request = server.takeRequest()
    assertThat(request.requestLine).isEqualTo("GET /foo HTTP/1.1")
  }

  @Test
  fun connectViaHttpsReusingConnections() {
    connectViaHttpsReusingConnections(false)
  }

  }

  @Test fun testParse() {
    val mediaType = parse("text/plain;boundary=foo;charset=utf-8")
    assertEquals("text", mediaType.type)
    assertEquals("plain", mediaType.subtype)
    assertEquals("UTF-8", mediaType.charsetName())
    assertEquals("text/plain;boundary=foo;charset=utf-8", mediaType.toString())
    assertEquals(mediaType, parse("text/plain;boundary=foo;charset=utf-8"))
    assertEquals(
      mediaType.hashCode(),

    val requestWithoutCache = Request.Builder().url("http://localhost/api").build()
    val builtRequestWithoutCache = requestWithoutCache.newBuilder().url("http://localhost/api/foo").build()
    assertThat(builtRequestWithoutCache.url).isEqualTo(
      "http://localhost/api/foo".toHttpUrl(),
    )
    val requestWithCache =
      Request.Builder()
        .url("http://localhost/api")
        .build()
    // cache url object

    val url = parse("http://host/?foo[]=1&foo[]=2&foo[]=3")
    assertThat(url.querySize).isEqualTo(3)
    assertThat(url.queryParameterNames).isEqualTo(setOf("foo[]"))
    assertThat(url.queryParameterValue(0)).isEqualTo("1")
    assertThat(url.queryParameterValue(1)).isEqualTo("2")
    assertThat(url.queryParameterValue(2)).isEqualTo("3")
    assertThat(url.queryParameterValues("foo[]")).containsExactly("1", "2", "3")
  }

  }

  @Test fun readPaddedHeadersFrame() {
    val paddingLength = 254
    val padding = ByteArray(paddingLength)
    Arrays.fill(padding, 0.toByte())
    val headerBlock = literalHeaders(headerEntries("foo", "barrr", "baz", "qux"))
    writeMedium(frame, headerBlock.size.toInt() + paddingLength + 1)
    frame.writeByte(Http2.TYPE_HEADERS)
    frame.writeByte(FLAG_END_HEADERS or FLAG_PADDED)