}
    }

    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"() {

                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

            taskDependencyFactory
        );
        instance.addMutationValidator(rootComponentMetadataBuilder.getValidator());
        return instance;
    }

    /**
     * Creates a new locked consumable configuration instance.
     */
    DefaultConsumableConfiguration createConsumable(
        String name,
        ConfigurationsProvider configurationsProvider,

            if (conf == null) {
                return null;
            }
            assert conf.getMetadata().isCanBeConsumed() : "External components' configurations are always consumable";
            return conf.asVariant();
        }
    }

        maybeEmitConsumptionDeprecation(conf);
        return conf;
    }

    /**
     * Ensures the target variant matches the request attributes and is consumable. This needs to be called
     * for variants that are selected by means other than attribute matching.
     *
     * Note: This does not need to be called for variants selected via attribute matching, since

        immutable3.variants[0].dependencies.size() == 2
        immutable3.variants[1].dependencies.size() == 1
        immutable3.variants[2].dependencies.empty
    }

    def "variants are attached as consumable configurations used for variant aware selection"() {
        def id = DefaultModuleComponentIdentifier.newId(DefaultModuleIdentifier.newId("group", "module"), "version")
        def metadata = createMetadata(id)

- `(n)`: A dependency or dependency configuration that <<declaring_dependencies.adoc#sec:resolvable-consumable-configs,cannot be resolved>>.

=== Specify a Dependency Configuration

To focus on the information about one dependency configuration, provide the optional parameter `--configuration`.

<2> Assign the <<variant_attributes.adoc#sub:gradle_plugins_default_attributes,Gradle API version attribute>> to all <<declaring_dependencies.adoc#sec:resolvable-consumable-configs,consumable configurations>> of our Gradle7 variant. Gradle uses this information to determine which variant to select during plugin resolution.