new ModuleMetadataSpec.LocalVariant(
                    variant.getName(),
                    attributesFor(variant.getAttributes()),
                    capabilitiesFor(variant.getCapabilities()),
                    dependenciesOf(variant, resolvers.getComponentResolver()),

               .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 " +

                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);

 *
 * <p>You can obtain a {@code ResolverContainer} instance by calling {@link org.gradle.api.Project#getRepositories()} or
 * using the {@code repositories} property in your build script.</p>
 *
 * <p>The resolvers in a container are accessible as read-only properties of the container, using the name of the
 * resolver as the property name. For example:</p>
 *
 * <pre class='autoTested'>
 * repositories.maven { name 'myResolver' }

            return repository.getDefaultBranch();
        }

        if (versionSelector.requiresMetadata()) {
            // TODO - implement this by moving this resolver to live alongside the external resolvers
            return null;
        }

        Set<VersionRef> versions = inMemoryCache.getVersionsForRepo(repository);
        if (versions == null) {
            versions = repository.getAvailableVersions();

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 --------------------------------------------------------------

        given:
        initialFiles()

        when:
        def dep5 = sourceFile("dep5")
        graph[dep5] = []
        parse(dep5)
        dependencyResolver.resolveAs("dep4", dep5)
        graph[source2] = [dep3, dep5]

        then:
        with(state) {
            recompile == [source2]
            removed == []
        }
    }

import static org.gradle.jvm.toolchain.JavaToolchainDownloadUtil.singleUrlResolverCode

// We need to test specifically versions before the toolchain provisioning was fixed that support resolvers.
@IgnoreVersions({ !it.isSupportsCustomToolchainResolvers() || it.isNonFlakyToolchainProvisioning() })
@Requires(IntegTestPreconditions.JavaHomeWithDifferentVersionAvailable)

        then:
        1 * action2.execute(_) >> { Ivy param ->
            assert param.settings.is(ivySettings)
            assert ivySettings.defaultResolverName == null
            assert ivySettings.resolvers.empty
            assert ivySettings.resolverNames.empty
        }
    }

    def "each thread is given a separate Ivy instance and context"() {
        given:
        def ivy1
        def ivySettings1