}
    }

    def "creates consumable configurations"() {
        expect:
        verifyRole(ConfigurationRoles.CONSUMABLE, "a") {
            consumable("a")
        }
        verifyRole(ConfigurationRoles.CONSUMABLE, "b") {
            consumable("b", {})
        }
        verifyUnlocked(ConfigurationRoles.CONSUMABLE, "c") {
            consumableUnlocked("c")
        }

        def parent = dependencyScope("parent")
        consumable("conf", [parent])

        expect:
        state.candidatesForGraphVariantSelection.getVariantByConfigurationName("conf", Stub(ResolutionFailureHandler))
    }

    def "configuration has no dependencies or artifacts when none have been added"() {
        given:
        def parent = dependencyScope("parent")
        consumable("conf", [parent])

        when:

        and: "Helpful resolutions are provided"
        assertSuggestsReviewingAlgorithm()
        assertSuggestsViewingDocs("Creating consumable variants is explained in more detail at https://docs.gradle.org/${GradleVersion.current().version}/userguide/declaring_dependencies.html#sec:resolvable-consumable-configs.")
    }

    // region Configuration requested by name
    def "demonstrate configuration not found selection failure"() {

import org.gradle.internal.reflect.Instantiator;
import org.gradle.internal.typeconversion.NotationParser;
import org.gradle.internal.work.WorkerThreadRegistry;

/**
 * A concrete consumable {@link DefaultConfiguration} that cannot change roles.
 */
public class DefaultConsumableConfiguration extends DefaultConfiguration implements ConsumableConfiguration {

    public DefaultConsumableConfiguration(

                return null;
            }

            // If the configuration exists, it must not be consumable, since variantsByConfigurationName contains
            // all consumable configurations.
            assert !conf.getMetadata().isCanBeConsumed() : "Expected configuration to be non-consumable";

            throw failureHandler.nonConsumableConfigurationFailure(name, component.getId());
        }

        @Override

    // This is needed because of the duplicate package-info.class files
    duplicatesStrategy = DuplicatesStrategy.WARN
}

// The consumable configuration containing the public Gradle API artifact
// and its external dependencies.
val gradleApiElements = configurations.consumable("gradleApiElements") {
    extendsFrom(externalApi.get())
    outgoing.artifact(task)
    configureAsRuntimeElements(objects)
}

    private static final String NO_MATCHING_VARIANTS_SECTION = "sub:variant-no-match";
    private static final String NO_VARIANTS_EXIST_PREFIX = "Creating consumable variants is explained in more detail at ";
    private static final String NO_VARIANTS_EXIST_SECTION = "sec:resolvable-consumable-configs";

    @Override
    public VariantSelectionException describeFailure(IncompatibleGraphVariantFailure failure, Optional<AttributesSchemaInternal> schema) {

 */
public interface ConfigurationMetadataFactory {

    /**
     * Visit all configurations in this component that can be selected in a dependency graph.
     *
     * <p>This includes all consumable configurations with and without attributes. Configurations visited
     * by this method may not be suitable for selection via attribute matching.</p>
     */

        }
    }
    repositories {
        maven {
            name = "test"
            url = testRepoLocation.get().asFile.toURI()
        }
    }
}

val testRepoElements = configurations.consumable("testRepoElements") {
    outgoing.artifact(testRepoLocation) {
        builtBy( "publishMavenPublicationToTestRepository")
    }
    // TODO: De-duplicate this. See publish-public-libraries
    attributes {

     * A cache of the defined dependencies for dependency configurations. This tracks the cached internal
     * dependency representations for these types so when constructing leaf configuration metadata
     * (resolvable and consumable), these conversions do not need to be executed multiple times.
     */
    class DependencyCache {
        private final Map<String, DefaultLocalConfigurationMetadataBuilder.DependencyState> cache = new HashMap<>();