Request
        .Builder()
        .url(server.url("/"))
    if (accept != null) {
      builder.header("Accept", accept)
    }
    val request = builder.build()
    val factory = createFactory(client)
    return factory.newEventSource(request, listener)
  }

    // Register SMB URL handler once for all tests
    @BeforeAll
    static void registerSmbHandler() {
        if (!handlerRegistered) {
            try {
                // Try to register the handler factory
                URL.setURLStreamHandlerFactory(new URLStreamHandlerFactory() {
                    @Override
                    public URLStreamHandler createURLStreamHandler(String protocol) {

  private Iterable<LoadingCache<Object, Object>> caches() {
    // lots of different ways to configure a LoadingCache
    CacheBuilderFactory factory = cacheFactory();
    return Iterables.transform(
        factory.buildAllPermutations(),
        new Function<CacheBuilder<Object, Object>, LoadingCache<Object, Object>>() {
          @Override

  private Iterable<LoadingCache<Object, Object>> caches() {
    // lots of different ways to configure a LoadingCache
    CacheBuilderFactory factory = cacheFactory();
    return Iterables.transform(
        factory.buildAllPermutations(),
        new Function<CacheBuilder<Object, Object>, LoadingCache<Object, Object>>() {
          @Override

    protected int maxDocumentCacheSize;

    /** Factory for creating ingesters to process documents */
    private IngestFactory ingestFactory = null;

    /**
     * Initializes the callback implementation after dependency injection.
     * Sets up configuration values and initializes the ingest factory if available.
     */
    @PostConstruct
    public void init() {

        List<Toolchain> toolchains = toolchainManager.getToolchains(session, "unknown", null);

        assertEquals(0, toolchains.size());
        verify(logger).error("Missing toolchain factory for type: unknown. Possibly caused by misconfigured project.");
    }

    @Test
    void testModelAndFactory() {
        MavenSession session = mock(MavenSession.class);

 *
 * Steps to run in your own code
 *
 * 1. In your main method `WireSharkListenerFactory.register()`
 * 2. Create Listener factory `val eventListenerFactory = WireSharkListenerFactory(
logFile = File("/tmp/key.log"), tlsVersions = tlsVersions, launch = launch)`
 * 3. Register with `client.eventListenerFactory(eventListenerFactory)`

 */
@Deprecated(since = "4.0.0")
public class ProblemCollectorFactory {

    /**
     * The default implementation is not visible, create it with this factory
     *
     * @param problems starting set of problems, may be {@code null}
     * @return a new instance of a ProblemCollector
     */
    public static ProblemCollector newInstance(List<Problem> problems) {

     */
    public void setNoWaitOnFolder(final boolean noWaitOnFolder) {
        this.noWaitOnFolder = noWaitOnFolder;
    }

    /**
     * Sets the client factory.
     * @param clientFactory The client factory.
     */
    public void setClientFactory(final CrawlerClientFactory clientFactory) {
        this.clientFactory = clientFactory;
    }

    /**
     * Sets the crawler context.

import java.util.Set;

import org.apache.maven.RepositoryUtils;
import org.apache.maven.artifact.Artifact;
import org.apache.maven.artifact.InvalidRepositoryException;
import org.apache.maven.artifact.factory.ArtifactFactory;
import org.apache.maven.artifact.metadata.ArtifactMetadataRetrievalException;
import org.apache.maven.artifact.metadata.ArtifactMetadataSource;
import org.apache.maven.artifact.metadata.ResolutionGroup;