process?.destroyForcibly()
      }
    }
  }

  private fun sendTestRequest(request: Request) {
    try {
      if (this.launch != CommandLine) {
        println(request.url)
      }

      client.newCall(request)
        .execute()
        .use {
          val firstLine =
            it.body.string()
              .lines()
              .first()

        Set<Artifact> artifacts = request.getArtifactDependencies();
        Map<String, Artifact> managedVersions = request.getManagedVersionMap();
        List<ResolutionListener> listeners = request.getListeners();
        ArtifactFilter collectionFilter = request.getCollectionFilter();
        ArtifactFilter resolutionFilter = request.getResolutionFilter();
        RepositorySystemSession session = getSession(request.getLocalRepository());

        ),
      )
      .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()
    val listener = loggingEventListenerFactory.create(call)

      MockResponse.Builder()
        .socketPolicy(DisconnectDuringRequestBody)
        .build(),
    )
    val request = NonCompletingRequestBody()
    val call =
      client.newCall(
        Request.Builder()
          .url(server.url("/"))
          .post(request)
          .build(),
      )
    assertFailsWith<IOException> {
      call.execute()
    }

        MetadataResolutionRequest request = new DefaultMetadataResolutionRequest();
        injectSession(request);
        request.setArtifact(artifact);
        request.setLocalRepository(localRepository);
        request.setRemoteRepositories(remoteRepositories);
        request.setResolveManagedVersions(resolveManagedVersions);
        return retrieve(request);
    }

    @Override

        request.setNoSnapshotUpdates(options.suppressSnapshotUpdates().orElse(false));
        request.setGoals(options.goals().orElse(List.of()));
        request.setReactorFailureBehavior(determineReactorFailureBehaviour(context));
        request.setRecursive(!options.nonRecursive().orElse(!request.isRecursive()));
        request.setOffline(options.offline().orElse(request.isOffline()));

            }

            if ( request != null ) {
                log.debug("Restting request");
                request.reset();
            }
            if ( rpath != null ) {
                // resolveDfs() and tree.send() modify the request packet.
                // I want to restore it before retrying. request.reset()

            }
        }

        request.uid = uid;
        request.auth = auth;
        try {
            transport.send( request, response );
        } catch (SmbException se) {
            if (request instanceof SmbComTreeConnectAndX) {
                logoff(true);
            }
            request.digest = null;
            throw se;
        }
}
    }

	}

	globalActiveCred = creds
	testCases := []struct {
		Request *http.Request
		ErrCode APIErrorCode
	}{
		{Request: mustNewRequest(http.MethodGet, "http://127.0.0.1:9000", 0, nil, t), ErrCode: ErrAccessDenied},
		{Request: mustNewSignedRequest(http.MethodGet, "http://127.0.0.1:9000", 0, nil, t), ErrCode: ErrNone},

        SettingsBuildingRequest request = new DefaultSettingsBuildingRequest();
        request.setUserSettingsFile(userSettingsFile);
        request.setGlobalSettingsFile(globalSettingsFile);
        request.setSystemProperties(SystemProperties.getSystemProperties());
        return build(request);
    }

    public Settings buildSettings(File userSettingsFile, boolean useCachedSettings)