assertWithMessage("null escaper should have no effect").that(escaper.escape(s)).isEqualTo(s);
  }

  public void testBuilderInitialStateNoReplacement() {
    // Unsafe characters aren't modified by default (unsafeReplacement == null).
    Escaper escaper = Escapers.builder().setSafeRange('a', 'z').build();
    assertThat(escaper.escape("The Quick Brown Fox")).isEqualTo("The Quick Brown Fox");
  }

    assertThat(bodyToHex(body)).isEqualTo("0800")
  }

  @Test
  fun byteArray() {
    val contentType = "text/plain".toMediaType()
    val body: RequestBody = "abc".toByteArray().toRequestBody(contentType)
    assertThat(body.contentType()).isEqualTo(contentType)
    assertThat(body.contentLength()).isEqualTo(3)
    assertThat(bodyToHex(body)).isEqualTo("616263")

    assertTrue(sink.wasStreamClosed());
    assertThat(sink.getString()).isEqualTo(STRING);
  }

  public void testWrite_string() throws IOException {
    assertThat(sink.getString()).isEqualTo("");
    sink.write(STRING);

    assertTrue(sink.wasStreamOpened() && sink.wasStreamClosed());
    assertThat(sink.getString()).isEqualTo(STRING);
  }

  public void testWriteFrom_reader() throws IOException {

    assertThat(encoded).isEqualTo("AAABAAABAAAAAAAABmdvb2dsZQNjb20AAAEAAQ")
  }

  private fun encodeQuery(
    host: String,
    type: Int,
  ): String = DnsRecordCodec.encodeQuery(host, type).base64Url().replace("=", "")

  @Test
  fun testGoogleDotComEncodingWithIPv6() {
    val encoded = encodeQuery("google.com", TYPE_AAAA)
    assertThat(encoded).isEqualTo("AAABAAABAAAAAAAABmdvb2dsZQNjb20AABwAAQ")
  }

    assertThat(formatDuration(-1_499_999_999L)).isEqualTo(" -1 s ")
    assertThat(formatDuration(-1_000_000_000L)).isEqualTo(" -1 s ")
    assertThat(formatDuration(  -999_500_000L)).isEqualTo(" -1 s ")
    assertThat(formatDuration(  -999_499_999L)).isEqualTo("-999 ms")
    assertThat(formatDuration(  -998_500_000L)).isEqualTo("-999 ms")
    assertThat(formatDuration(  -998_499_999L)).isEqualTo("-998 ms")

          ipv6_ab,
          ipv6_fc,
        ),
      )

    assertThat(result).isEqualTo(
      listOf(ipv6_ab, ipv4_10_0_0_6, ipv6_fc, ipv4_10_0_0_1, ipv4_10_0_0_4),
    )
  }

  @Test fun ipv6Only() {
    val result = reorderForHappyEyeballs(listOf(ipv6_ab, ipv6_fc))

    assertThat(result).isEqualTo(
      listOf(ipv6_ab, ipv6_fc),
    )
  }

  @Test fun ipv4Only() {
    val result =

    assertThat(response1.body.string()).isEqualTo("abc")
    val request2 = Request.Builder().url(server.url("/")).build()
    val response2 = client.newCall(request2).execute()
    assertThat(response2.body.string()).isEqualTo("def")

    // The HTTP calls should share a single connection.
    assertThat(socksProxy.connectionCount()).isEqualTo(1)
  }

  @Test
  fun proxySelector() {

    assertThat(LOWER_HYPHEN.to(LOWER_CAMEL, "foo-bar")).isEqualTo("fooBar");
  }

  public void testLowerHyphenToUpperCamel() {
    assertThat(LOWER_HYPHEN.to(UPPER_CAMEL, "foo")).isEqualTo("Foo");
    assertThat(LOWER_HYPHEN.to(UPPER_CAMEL, "foo-bar")).isEqualTo("FooBar");
  }

  public void testLowerHyphenToUpperUnderscore() {
    assertThat(LOWER_HYPHEN.to(UPPER_UNDERSCORE, "foo")).isEqualTo("FOO");

    assertThat(cache.getIfPresent(2)).isEqualTo(20);
    assertThat(cache.getIfPresent(3)).isEqualTo(30);
    assertThat(cache.getIfPresent(4)).isEqualTo(40);
    assertThat(cache.getIfPresent(5)).isEqualTo(50);

    cache.put(1, 10);
    assertThat(cache.getIfPresent(1)).isEqualTo(10);
    assertThat(cache.getIfPresent(3)).isEqualTo(30);
    assertThat(cache.getIfPresent(4)).isEqualTo(40);

    assertThat(emptyAccumulator.count()).isEqualTo(0);
    assertThat(emptyAccumulatorByAddAllEmptyIterable.count()).isEqualTo(0);
    assertThat(emptyAccumulatorByAddAllEmptyStats.count()).isEqualTo(0);
    assertThat(oneValueAccumulator.count()).isEqualTo(1);
    assertThat(oneValueAccumulatorByAddAllEmptyStats.count()).isEqualTo(1);
    assertThat(twoValuesAccumulator.count()).isEqualTo(2);