assertThat(it.protocol).isEqualTo(Protocol.HTTP_2)
      assertThat(it.handshake!!.tlsVersion).isEqualTo(TlsVersion.TLS_1_3)
    }
  }

  @Test
  @Disabled
  fun testGoogle() {
    assumeNetwork()

    val request = Request.Builder().url("https://google.com/robots.txt").build()

    client.newCall(request).execute().use {
      assertThat(it.protocol).isEqualTo(Protocol.HTTP_2)

      }
    }
  }

  @Test
  fun successfulEmptyH2CallEventSequence() {
    enableTlsWithTunnel()
    server.protocols = Arrays.asList(Protocol.HTTP_2, Protocol.HTTP_1_1)
    server.enqueue(MockResponse())
    assertSuccessfulEventOrder(matchesProtocol(Protocol.HTTP_2))
    assertBytesReadWritten(
      listener,
      CoreMatchers.any(Long::class.java),
      null,
      greaterThan(0L),

    url = server.url("/")
    setLevel(Level.BASIC)
    server.enqueue(MockResponse())
    val response = client.newCall(request().build()).execute()
    Assumptions.assumeTrue(response.protocol == Protocol.HTTP_2)
    applicationLogs
      .assertLogEqual("--> GET $url")
      .assertLogMatch(Regex("""<-- 200 $url \(\d+ms, 0-byte body\)"""))
      .assertNoMoreLogs()
    networkLogs
      .assertLogEqual("--> GET $url h2")

  }

  @Test
  fun serverTruncatesRequestOnLongPostHttp1() {
    serverTruncatesRequestOnLongPost(https = false)
  }

  @Test
  fun serverTruncatesRequestOnLongPostHttp2() {
    enableProtocol(Protocol.HTTP_2)
    serverTruncatesRequestOnLongPost(https = true)
  }

  private fun serverTruncatesRequestOnLongPost(https: Boolean) {
    server.enqueue(
      MockResponse(
        body = "abc",

        .header("Host", "cloudflare-dns.com")
        .build()
    client.newCall(request).execute().use { response ->
      assertThat(response.code).isEqualTo(200)
      assertThat(response.protocol).isEqualTo(Protocol.HTTP_2)

      assertThat(response.body.string()).contains("h=cloudflare-dns.com")
    }
  }

  @Test
  fun getWithDns() {
    client =
      client.newBuilder()
        .dns {

serial numbers that are negative. This change can be reverted with
the [`x509negativeserial` setting](/pkg/crypto/x509/#ParseCertificate).

Go 1.23 re-enabled support in html/template for ECMAScript 6 template literals by default.
The [`jstmpllitinterp` setting](/pkg/html/template#hdr-Security_Model) no longer has
any effect.

Go 1.23 changed the default TLS cipher suites used by clients and servers when

    val response = client.newCall(request).execute()

    response.use {
      assertEquals(200, response.code)
      assertEquals(TlsVersion.TLS_1_3, response.handshake?.tlsVersion)
      assertEquals(Protocol.HTTP_2, response.protocol)

      assertThat(response.exchangeAccessor!!.connectionAccessor.socket())
        .isInstanceOf<SSLSocketImpl>()
    }
  }

  @Test
  fun testSupportedProtocols() {

    server.enqueue(MockResponse(code = 500))
    executeSynchronously("/")
      .assertCode(500)
      .assertNotSuccessful()
  }

  @Test
  fun get_HTTP_2() {
    enableProtocol(Protocol.HTTP_2)
    get()
  }

  @Test
  fun get_HTTPS() {
    enableTls()
    get()
  }

  @Test
  fun repeatedHeaderNames() {
    server.enqueue(
      MockResponse(
        headers =

        assertEquals("http://hoge/index.html", htmlTransformer.normalizeUrl(url));

        url = "http://hoge/index.html;jsessionid=hoge?a=1";
        assertEquals("http://hoge/index.html?a=1", htmlTransformer.normalizeUrl(url));

        url = "http://hoge/index.html;jsessionid=hoge.fuga?a=1";
        assertEquals("http://hoge/index.html?a=1", htmlTransformer.normalizeUrl(url));

   ** profile injection: <<<ProfileInjector>>> ({{{./apidocs/org/apache/maven/model/profile/ProfileInjector.html}javadoc}}),
   with its <<<DefaultProfileInjector>>> implementation
   ({{{./xref/org/apache/maven/model/profile/DefaultProfileInjector.html}source}})

   ** parent resolution until {{{./super-pom.html}super-pom}}

   ** inheritance assembly (see {{{./index.html#Inheritance_Assembly}below}})