override fun onRedirectReceived(
              request: UrlRequest,
              info: UrlResponseInfo,
              newLocationUrl: String,
            ) {
              println("request " + info.httpStatusCode + " " + newLocationUrl)
              request.followRedirect()
            }

            override fun onResponseStarted(
              request: UrlRequest,
              info: UrlResponseInfo,

        ),
      ).assertNoMoreLogs()
  }

  @Test
  fun testCacheEvents() {
    val request = Request.Builder().url(url).build()
    val call = client.newCall(request)
    val response =
      Response
        .Builder()
        .request(request)
        .code(200)
        .message("")
        .protocol(Protocol.HTTP_2)
        .build()

            }

            throw e;
        }
    }

    private File getRootProject(MavenExecutionRequest request) {
        Path rootDirectory = request.getRootDirectory();
        if (request.getPom().getParentFile().toPath().equals(rootDirectory)) {
            return request.getPom();
        } else {
            Path rootProjectPom = modelProcessor.locateExistingPom(rootDirectory);

    public DefaultProjectBuildingRequest(ProjectBuildingRequest request) {
        this();
        setProcessPlugins(request.isProcessPlugins());
        setProfiles(request.getProfiles());
        setActiveProfileIds(request.getActiveProfileIds());
        setInactiveProfileIds(request.getInactiveProfileIds());
        setSystemProperties(request.getSystemProperties());
        setUserProperties(request.getUserProperties());

                k3(),
                k -> {
                  assertEquals(k3(), k);
                  return v3();
                }));
    expectAdded(e3());
  }

  @MapFeature.Require(SUPPORTS_PUT)
  @CollectionSize.Require(absent = ZERO)
  public void testComputeIfAbsent_supportedPresent() {
    assertEquals(
        "computeIfAbsent(present, function) should return existing value",
        v0(),
        getMap()

    return (ConcurrentMap<K, V>) super.getMap();
  }

  @MapFeature.Require(SUPPORTS_PUT)
  public void testPutIfAbsent_supportedAbsent() {
    assertNull("putIfAbsent(notPresent, value) should return null", putIfAbsent(e3()));
    expectAdded(e3());
  }

  @MapFeature.Require(SUPPORTS_PUT)
  @CollectionSize.Require(absent = ZERO)
  public void testPutIfAbsent_supportedPresent() {
    assertEquals(

	public static synthetic fun delete$default (Lokhttp3/Request$Builder;Lokhttp3/RequestBody;ILjava/lang/Object;)Lokhttp3/Request$Builder;
	public fun get ()Lokhttp3/Request$Builder;
	public final fun gzip ()Lokhttp3/Request$Builder;
	public fun head ()Lokhttp3/Request$Builder;
	public fun header (Ljava/lang/String;Ljava/lang/String;)Lokhttp3/Request$Builder;
	public fun headers (Lokhttp3/Headers;)Lokhttp3/Request$Builder;

  @MapFeature.Require(SUPPORTS_PUT)
  @CollectionSize.Require(absent = ZERO)
  public void testReplace_supportedPresent() {
    try {
      assertEquals(v0(), getMap().replace(k0(), v3()));
      expectReplacement(entry(k0(), v3()));
    } catch (ClassCastException tolerated) { // for ClassToInstanceMap
      expectUnchanged();
    }
  }

  @MapFeature.Require(SUPPORTS_PUT)

  @Test
  fun testHttpsRequest() {
    server.useHttps(handshakeCertificates.sslSocketFactory())

    server.enqueue(MockResponse())
    server.start()

    val request = Request.Builder().url(server.url("/")).build()

    val response = client.newCall(request).execute()

    response.use {
      assertEquals(200, response.code)
    }

    while (client.connectionPool.connectionCount() > 0) {
      Thread.sleep(1000)

  }

  @MapFeature.Require(SUPPORTS_PUT)
  @CollectionSize.Require(SEVERAL)
  public void testSetValue_valuePresent() {
    for (Entry<K, V> entry : getMap().entrySet()) {
      if (entry.getKey().equals(k0())) {
        assertThrows(IllegalArgumentException.class, () -> entry.setValue(v1()));
      }
    }
    expectUnchanged();
  }

  @MapFeature.Require(value = SUPPORTS_PUT, absent = ALLOWS_NULL_VALUES)