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

    assertThat(graph.edgeValue(2, 1).orElse(DEFAULT)).isEqualTo(DEFAULT);
    assertThat(graph.edgeValueOrDefault(1, 2, null)).isNull();
    assertThat(graph.edgeValueOrDefault(2, 1, null)).isNull();
    assertThat(graph.edgeValue(1, 2).orElse(null)).isNull();
    assertThat(graph.edgeValue(2, 1).orElse(null)).isNull();

    graph.putEdgeValue(1, 2, "valueA");
    graph.putEdgeValue(2, 1, "valueB");

    assertThat(fooReference1).isNotSameInstanceAs(fooReference2);

    assertThat(mapCache.put(fooReference1, "bar")).isNull();
    assertThat(mapCache.get(fooReference1)).isEqualTo("bar"); // ensure first reference is cached
    assertThat(mapCache.remove(fooReference2)).isEqualTo("bar");
    assertThat(mapCache.get(fooReference1)).isNull();
  }

 * limitations under the License.
 */
package okhttp3.internal.platform

import assertk.assertThat
import assertk.assertions.isNotNull
import assertk.assertions.isNull
import okhttp3.internal.platform.Jdk8WithJettyBootPlatform.Companion.buildIfSupported
import okhttp3.testing.PlatformRule
import org.junit.jupiter.api.Assumptions.assumeFalse
import org.junit.jupiter.api.Assumptions.assumeTrue

    assertThat(response.handshake!!.localCertificates).isEmpty()
    assertThat(response.handshake!!.localPrincipal).isNull()
    assertThat(response.handshake!!.peerCertificates).isEmpty()
    assertThat(response.handshake!!.peerPrincipal).isNull()
  }

  @Test fun `bad certificates host in insecureHosts fails with SSLException`() {
    val heldCertificate =
      HeldCertificate.Builder()

    assertThat(graph.removeEdge(1, 2)).isEqualTo("valueA");
    assertThat(graph.removeEdge(1, 2)).isNull();
    assertThat(graph.removeEdge(2, 1)).isEqualTo("valueB");
    assertThat(graph.removeEdge(2, 1)).isNull();
    assertThat(graph.removeEdge(2, 3)).isEqualTo("valueC");
    assertThat(graph.removeEdge(2, 3)).isNull();
  }

  @Test
  public void removeEdge_undirected() {

    assertThat("Thu, 01 Jan 1970 00:00:00".toHttpDateOrNull()).isNull()
    // Missing seconds treated as bad.
    assertThat("Thu, 01 Jan 1970 00:00 GMT".toHttpDateOrNull()).isNull()
    // Extra spaces treated as bad.
    assertThat("Thu,  01 Jan 1970 00:00 GMT".toHttpDateOrNull()).isNull()
    // Missing leading zero treated as bad.
    assertThat("Thu, 1 Jan 1970 00:00 GMT".toHttpDateOrNull()).isNull()

    // RFC 850, obsoleted by RFC 1036 with any TZ.

  fun assertNoNetworkResponse() =
    apply {
      assertThat(response!!.networkResponse).isNull()
    }

  /** Asserts that the current response didn't use the cache.  */
  fun assertNoCacheResponse() =
    apply {
      assertThat(response!!.cacheResponse).isNull()
    }

  /**
   * Asserts that the current response used the cache and returns the cache response.
   */

    assumeNetwork()

    val (allAddresses, exception) = dnsQuery("google.com")

    assertThat(exception).isNull()
    assertThat(allAddresses).isNotEmpty()
  }

  @Test
  fun testDnsRequestInvalid() {
    val (allAddresses, exception) = dnsQuery("google.invalid")

    assertThat(exception).isNull()
    assertThat(allAddresses).isEmpty()
  }

  @Test
  fun testRequestOnNetwork() {

    assertFalse(equalTo1.apply(null));
    Predicate<@Nullable Object> isNull = Equivalence.equals().equivalentTo(null);
    assertFalse(isNull.apply("1"));
    assertFalse(isNull.apply("2"));
    assertTrue(isNull.apply(null));

    new EqualsTester()
        .addEqualityGroup(equalTo1, Equivalence.equals().equivalentTo("1"))
        .addEqualityGroup(isNull)
        .addEqualityGroup(Equivalence.identity().equivalentTo("1"))