ComponentResolvers resolvers = getResolvers(resolveContext, Collections.emptyList());
        DependencyGraphVisitor artifactsGraphVisitor = artifactVisitorFor(artifactsBuilder, resolvers);

        ImmutableList<DependencyGraphVisitor> visitors = ImmutableList.of(failureCollector, resolutionResultBuilder, localComponentsVisitor, artifactsGraphVisitor);
        doResolve(resolveContext, resolvers, false, IS_LOCAL_EDGE, visitors);

    private final List<Resolver> resolvers;
    private final Map<String, Set<NodeState>> capabilityWithoutVersionToNodes = new HashMap<>();
    private final Deque<CapabilityConflict> conflicts = new ArrayDeque<>();

    public DefaultCapabilitiesConflictHandler(List<Resolver> resolvers) {
        this.resolvers = resolvers;
    }

    @Override

        resolver
    }

    private void mockRegistry(JavaToolchainResolver... resolvers) {
        def repositories = IntStream.range(0, resolvers.length)
            .mapToObj { i -> mockRepository("resolver" + i, resolvers[i]) }
            .collect(Collectors.toList())

        registry.requestedRepositories() >> repositories
    }

                .assertHasCause("No matching toolchain could be found in the locally installed toolchains or the configured toolchain download repositories. " +
                    "Some toolchain resolvers had provisioning failures: custom (Unable to download toolchain matching the requirements " +
                    "({languageVersion=99, vendor=matching('exotic'), implementation=vendor-specific}) from '$archiveUri', " +

	testenv.SkipFlakyNet(t)

	defer dnsWaitGroup.Wait()

	resolvers := make([]*lookupCustomResolver, 2)
	for i := range resolvers {
		cs := lookupCustomResolver{Resolver: &Resolver{PreferGo: true}}
		cs.Dial = cs.dial()
		resolvers[i] = &cs
	}

	var wg sync.WaitGroup
	wg.Add(len(resolvers))
	for i, resolver := range resolvers {
		go func(r *Resolver, index int) {
			defer wg.Done()

            this.workingDirResolver = workingDirResolver;
        }

        @Override
        public void create(Collection<ComponentResolvers> resolvers, LocalComponentRegistry localComponentRegistry) {
            if (vcsResolver.hasRules()) {
                resolvers.add(new VcsDependencyResolver(
                    localComponentRegistry, vcsResolver, versionControlSystemFactory,

		// Mark all UDP dns traffic with dst port 53 as zone 2. These are application client packets towards DNS resolvers.
		f.Run("-p", "udp", "--dport", "53",
			"-j", constants.CT, "--zone", "2")
		// Mark all UDP dns traffic with src port 53 as zone 1. These are response packets from the DNS resolvers.
		f.WithChain(constants.PREROUTING).Run("-p", "udp", "--sport", "53",
			"-j", constants.CT, "--zone", "1")
	} else {

                sb.append("Some toolchain resolvers had internal failures: ")
                    .append(failureMessage(resolveFailures))
                    .append(".");
            }
            if (!provisioningFailures.isEmpty()) {
                sb.append(resolveFailures.isEmpty() ? "" : " ");
                sb.append("Some toolchain resolvers had provisioning failures: ")

import org.gradle.internal.resolve.result.BuildableComponentResolveResult;
import org.gradle.util.internal.BuildCommencedTimeProvider;

import javax.annotation.Nullable;
import java.util.Collection;

/**
 * Creates resolvers that can resolve module components from repositories.
 */
public class ExternalModuleComponentResolverFactory {

    private final static Logger LOGGER = Logging.getLogger(ExternalModuleComponentResolverFactory.class);

import org.junit.jupiter.api.BeforeEach;

import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertNotNull;

/**
 * Provides a basis for testing conflict resolvers.
 *
 */
@PlexusTest
@Deprecated
public abstract class AbstractConflictResolverTest {
    // constants --------------------------------------------------------------