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(cache.getUnchecked(entry.getKey())).isEqualTo(newValue);
        assertThat(cache.getUnchecked(newKey)).isEqualTo(entry.getValue());
        // don't let the new entry get GCed
        warmed.add(entryOf(newKey, entry.getValue()));
      }
      assertThat(cache.stats().missCount()).isEqualTo(WARMUP_SIZE);
      checkValidState(cache);
    }
  }

    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(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() {

 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
package okhttp3

import assertk.assertThat
import assertk.assertions.isEqualTo
import assertk.assertions.isFalse
import assertk.assertions.isNotNull
import assertk.assertions.isTrue
import java.io.IOException
import java.io.InterruptedIOException
import java.net.HttpURLConnection

    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")

      |
      |
      """.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(
      """
      |: test stream
      |
      |data: first event

  }

  public void testCount() {
    assertThat(emptyAccumulator.count()).isEqualTo(0);
    assertThat(emptyAccumulatorByAddAllEmptyPairedStats.count()).isEqualTo(0);
    assertThat(oneValueAccumulator.count()).isEqualTo(1);
    assertThat(oneValueAccumulatorByAddAllEmptyPairedStats.count()).isEqualTo(1);
    assertThat(twoValuesAccumulator.count()).isEqualTo(2);

    // First response is still waiting.
    assertThat(firstResponseCode.get()).isEqualTo(0)
    // Second response is done.
    assertThat(secondResponseCode.get()).isEqualTo(200)
    latch.countDown()
    startsFirst.join()
    // And now it's done!
    assertThat(firstResponseCode.get()).isEqualTo(200)
    // (Still done).
    assertThat(secondResponseCode.get()).isEqualTo(200)
  }

  private fun buildRequestThread(
    path: String,