assertThat(response.code).isEqualTo(200)
    assertThat(response.message).isEqualTo("Fantastic")
    val responseHeaders = response.headers
    assertThat(LinkedHashSet(responseHeaders.values("A"))).isEqualTo(newSet("c", "e"))
    assertThat(LinkedHashSet(responseHeaders.values("a"))).isEqualTo(newSet("c", "e"))
    assertThat(responseHeaders.name(0)).isEqualTo("A")
    assertThat(responseHeaders.value(0)).isEqualTo("c")

      |data: 2153
      |
      |event: add
      |data: 113411
      |
      |
      """.trimMargin(),
    )
    assertThat(callbacks.remove()).isEqualTo(Event(null, "add", "73857293"))
    assertThat(callbacks.remove()).isEqualTo(Event(null, "remove", "2153"))
    assertThat(callbacks.remove()).isEqualTo(Event(null, "add", "113411"))
  }

  @Test
  fun commentsIgnored() {
    consumeEvents(
      """

        assertThat(args.length, is(2));
        assertThat(args[0].getRawClass(), is(sameClass(String.class)));
        assertThat(args[0].getArguments(), is(nullValue()));
        assertThat(args[1].getRawClass(), is(sameClass(Integer.class)));
        assertThat(args[1].getArguments(), is(nullValue()));
    }

    /**
     * @throws Exception
     */
    @Test
    public void testMethodReturnType() throws Exception {

    val heldCertificate = decode(pkcs8Pem + certificatePem)
    assertThat(heldCertificate.certificatePem()).isEqualTo(certificatePem)
    assertThat(heldCertificate.privateKeyPkcs8Pem()).isEqualTo(pkcs8Pem)
    val certificate = heldCertificate.certificate
    assertThat(certificate.notBefore.time).isEqualTo(5000L)
    assertThat(certificate.notAfter.time).isEqualTo(10000L)
    assertThat(certificate.subjectAlternativeNames.toList()).containsExactly(

    /**
     * @throws Exception
     */
    @Test
    public void testToDate_Null() throws Exception {
        assertThat(toDate(null), is(nullValue()));
    }

    /**
     * @throws Exception
     */
    @Test
    public void testToDate_EmptyString() throws Exception {
        assertThat(toDate(""), is(nullValue()));
    }

    /**
     * @throws Exception
     */
    @Test

        assertThat(ObjectUtil.equals("", null), is(false));
        assertThat(ObjectUtil.equals("", ""), is(true));
        assertThat(ObjectUtil.equals(Boolean.TRUE, null), is(false));
        assertThat(ObjectUtil.equals(Boolean.TRUE, "true"), is(false));
        assertThat(ObjectUtil.equals(Boolean.TRUE, Boolean.TRUE), is(true));
        assertThat(ObjectUtil.equals(Boolean.TRUE, Boolean.FALSE), is(false));
    }

      assertThat(urls.get(0).getProtocol()).isEqualTo("file");
      assertThat(urls.get(0).getAuthority()).isNull();
      assertThat(urls.get(0).getPath()).endsWith("/relative/path/to/some.jar");

      assertThat(urls.get(1)).isEqualTo(new URL("file:///absolute/path/to/some.jar"));

      assertThat(urls.get(2).getProtocol()).isEqualTo("file");
      assertThat(urls.get(2).getAuthority()).isNull();

    assertThat(result).asList().containsExactly("foo", "bar", "baz").inOrder();
  }

  public void testAppendZeroElements() {
    String[] result = ObjectArrays.concat(new String[] {}, "foo");
    assertThat(result).asList().contains("foo");
  }

  public void testAppendOneElement() {
    String[] result = ObjectArrays.concat(new String[] {"foo"}, "bar");

          headers = headersOf("Host", "header-host"),
        ),
      )
    val response = call.execute()
    assertThat(response.isSuccessful).isTrue()

    val recordedRequest = server.takeRequest()
    assertThat(recordedRequest.requestUrl!!.host).isEqualTo("header-host")
    assertThat(recordedRequest.handshakeServerNames).containsExactly("url-host.com")
  }

  /** No SNI for literal IPv6 addresses. */
  @Test

    val response = httpClient.send(request, BodyHandlers.ofString())
    assertThat(response.statusCode()).isEqualTo(200)
    assertThat(response.body()).isEqualTo("hello, Java HTTP Client")

    val recorded = server.takeRequest()
    assertThat(recorded.headers["Accept"]).isEqualTo("text/plain")
    assertThat(recorded.headers["Accept-Encoding"]).isNull() // No built-in gzip.
    assertThat(recorded.headers["Connection"]).isEqualTo("Upgrade, HTTP2-Settings")