private val client = OkHttpClient()

  @Test
  fun passingTest() {
    assertThat("hello").isEqualTo("hello")
  }

  @Test
  fun testMockWebServer() {
    server.enqueue(MockResponse(body = "abc"))
    server.start()

    client.newCall(Request(url = server.url("/"))).execute().use {
      assertThat(it.body.string()).isEqualTo("abc")
    }
  }

  @Test
  fun testExternalSite() {

  @Test
  fun defaultPrefix() {
    assertThat(Platform().getPrefix()).isEqualTo("OkHttp")
  }

  @Test
  fun testToStringIsClassname() {
    assertThat(Platform().toString()).isEqualTo("Platform")
  }

  @Test
  fun testNotAndroid() {
    platform.assumeNotAndroid()

    // This is tautological so just confirms that it runs.
    assertThat(isAndroid).isEqualTo(false)
  }

      )
    val requestLine = decodeRequestLine("CONNECT example.com:8080 HTTP/1.1")
    val request = RecordedRequest(requestLine, headers, emptyList(), 0, ByteString.EMPTY, 0, 0, socket)
    assertThat(request.target).isEqualTo("example.com:8080")
    assertThat(request.url.toString()).isEqualTo("http://example.com:8080/")
  }

  @Test fun testAbsoluteForm() {
    val socket =
      MockWebServerSocket(
        FakeSocket(

    assertThat(network.nodes()).containsExactly(N1, N5, N4, N2, N3);
    assertThat(network.edges()).containsExactly(E15, E41, E23);
    assertThat(network.edgesConnecting(N1, N5)).containsExactly(E15);
    assertThat(network.edgesConnecting(N4, N1)).containsExactly(E41);
    assertThat(network.edgesConnecting(N2, N3)).containsExactly(E23);
    assertThat(network.edgesConnecting(N3, N2)).containsExactly(E23);

      .isEqualTo("google.co.uk")
    assertThat("https://栃.栃木.jp".toHttpUrl().topPrivateDomain())
      .isEqualTo("xn--ewv.xn--4pvxs.jp")
    assertThat("https://xn--ewv.xn--4pvxs.jp".toHttpUrl().topPrivateDomain())
      .isEqualTo("xn--ewv.xn--4pvxs.jp")
    assertThat("https://co.uk".toHttpUrl().topPrivateDomain()).isNull()
    assertThat("https://square".toHttpUrl().topPrivateDomain()).isNull()

        e = list.getLastEntry();
        assertThat(e.getNext(), is(nullValue()));
        assertThat(e.getPrevious().getElement(), is("2"));
        list.getEntry(1).remove();
        assertThat(list.getFirst(), is("1"));
        assertThat(list.getLast(), is("3"));
        list.getLastEntry().remove();
        assertThat(list.getLast(), is("1"));
        list.getLastEntry().remove();
        assertThat(list.size(), is(0));
    }

    // IPv6
    assertThat("::1".toCanonicalHost()).isEqualTo("::1")
    assertThat("2001:db8::1".toCanonicalHost()).isEqualTo("2001:db8::1")
    assertThat("::ffff:192.168.0.1".toCanonicalHost()).isEqualTo("192.168.0.1")
    assertThat(
      "FEDC:BA98:7654:3210:FEDC:BA98:7654:3210".toCanonicalHost(),
    ).isEqualTo(
      "fedc:ba98:7654:3210:fedc:ba98:7654:3210",
    )

    assertThat(

    assertThat("0:0:0:0:0:FFFF:129.144.52.38".canParseAsIpAddress()).isTrue()
    assertThat("::13.1.68.3".canParseAsIpAddress()).isTrue()
    assertThat("::FFFF:129.144.52.38".canParseAsIpAddress()).isTrue()

    // Hostnames
    assertThat("go".canParseAsIpAddress()).isFalse()
    assertThat("localhost".canParseAsIpAddress()).isFalse()
    assertThat("squareup.com".canParseAsIpAddress()).isFalse()

    val call = client.newCall(Request.Builder().url(server.url("/")).build())
    val response = call.execute()
    assertThat(response.handshake!!.peerPrincipal)
      .isEqualTo(X500Principal("CN=Local Host"))
    assertThat(response.handshake!!.localPrincipal)
      .isEqualTo(X500Principal("CN=Jethro Willis"))
    assertThat(response.body.string()).isEqualTo("abc")
  }

  @Test
  fun clientAuthForNeeds() {

    assertThat(encoding.canDecode(encoded)).isTrue();
    assertThat(encoding.decode(encoded)).isEqualTo(decoded.getBytes(UTF_8));
  }

  private static void testDecodesByBytes(BaseEncoding encoding, String encoded, byte[] decoded) {
    assertThat(encoding.canDecode(encoded)).isTrue();
    assertThat(encoding.decode(encoded)).isEqualTo(decoded);
  }