CacheBuilder.newBuilder().expireAfterWrite(10L, DAYS), CacheBuilder.from(spec));
  }

  public void testParse_writeExpirationHours() {
    CacheBuilderSpec spec = parse("expireAfterWrite=150h");
    assertEquals(HOURS, spec.writeExpirationTimeUnit);
    assertEquals(150L, spec.writeExpirationDuration);
    assertCacheBuilderEquivalence(

    val differentDnsUrl = url.newBuilder().host("differentdns.com").build()
    assertFailsWith<IOException> {
      execute(differentDnsUrl)
    }
  }

  @Test
  fun skipsOnRedirectWhenDnsDontMatch() {
    server.enqueue(
      MockResponse.Builder()
        .code(301)
        .addHeader("Location", url.newBuilder().host("differentdns.com").build())
        .build(),
    )

        val sameHost = address.url.host
        val differentPort = address.url.port + 1
        chain.proceed(
          chain.request().newBuilder()
            .url("http://$sameHost:$differentPort/")
            .build(),
        )
      }
    client =
      client.newBuilder()
        .addNetworkInterceptor(interceptor)
        .build()
    val request =
      Request.Builder()
        .url(server.url("/"))

    public void shouldInterpolateSourceDirectoryReferencedFromResourceDirectoryCorrectly() throws Exception {
        Model model = Model.newBuilder()
                .build(Build.newBuilder()
                        .sourceDirectory("correct")
                        .resources(Arrays.asList(Resource.newBuilder()
                                .directory("${project.build.sourceDirectory}")
                                .build()))

        activator = new OperatingSystemProfileActivator();
    }

    private Profile newProfile(ActivationOS.Builder activationBuilder) {
        Activation a = Activation.newBuilder().os(activationBuilder.build()).build();

        Profile p = Profile.newBuilder().activation(a).build();

        return p;
    }

    private Properties newProperties(String osName, String osVersion, String osArch) {

      .isEqualTo(parse("http://host/a/b?query"))
    assertThat(base.newBuilder("#fragment")!!.build())
      .isEqualTo(parse("http://host/a/b#fragment"))
    assertThat(base.newBuilder("")!!.build()).isEqualTo(parse("http://host/a/b"))
    assertThat(base.newBuilder("ftp://b")).isNull()
    assertThat(base.newBuilder("ht+tp://b")).isNull()
    assertThat(base.newBuilder("ht-tp://b")).isNull()

        .build().also {
          listener.satisfactionFailure(call, it)
        }
    }

    // If we don't need the network, we're done.
    if (networkRequest == null) {
      return cacheResponse!!.newBuilder()
        .cacheResponse(cacheResponse.stripBody())
        .build().also {
          listener.cacheHit(call, it)
        }
    }

    if (cacheResponse != null) {

   */
  private fun enableProtocol(protocol: Protocol) {
    enableTls()
    client =
      client.newBuilder()
        .protocols(listOf(protocol, Protocol.HTTP_1_1))
        .build()
    server.protocols = client.protocols
  }

  private fun enableTls() {
    client =
      client.newBuilder()
        .sslSocketFactory(
          handshakeCertificates.sslSocketFactory(),

        () -> CacheBuilder.newBuilder().weigher(constantWeigher(42)).maximumSize(1));
    assertThrows(
        IllegalStateException.class,
        () -> CacheBuilder.newBuilder().maximumSize(1).weigher(constantWeigher(42)));
  }

  @GwtIncompatible // weakKeys
  public void testKeyStrengthSetTwice() {
    CacheBuilder<Object, Object> builder1 = CacheBuilder.newBuilder().weakKeys();

        Model initial = new Model(org.apache.maven.api.model.Model.newBuilder()
                .parent(org.apache.maven.api.model.Parent.newBuilder()
                        .groupId("GROUPID")
                        .artifactId("ARTIFACTID")
                        .build())
                .build());
        Model expected = new Model(org.apache.maven.api.model.Model.newBuilder()
                .parent(org.apache.maven.api.model.Parent.newBuilder()