* configurations, compile task, and jar task. This feature creates a jar task and javadoc task, and
 * can optionally also create consumable javadoc and sources jar variants.
 *
 * <p>This can be used to create production libraries, applications, test suites, test fixtures,
 * or any other consumable JVM feature.</p>
 *
 * <p>This feature can conditionally be configured to instead "extend" the production code. In that case, this

 * <p>
 * This test aims to mirror the actual variant selection process within Gradle, specifically when one project
 * is resolving their own configurations which in turn depend on the consumable configurations of other Gradle
 * projects. This test does not attempt to model or test the interactions with published artifacts.
 */
class JavaEcosystemAttributeMatcherTest extends Specification {

        return selectedConfiguration;
    }

    /**
     * Fails the resolution of the project dependency because the selected configuration is not consumable by
     * throwing the appropriate exception.
     *
     * This method is kind of ugly.  If we could get a hold of the ResolutionFailureHandler in this class, we could use the typical

        expect:
        succeeds("resolve")
    }

    def "buildscript resolvable configuration and consumable configuration from same project live in same resolved component"() {
        buildFile << """
            buildscript {
                configurations {
                    conf {

     * the project it belongs to. The default value is true.
     *
     * @implSpec Usage: This method should only be called on consumable configurations, but will not warn if used otherwise.
     *
     * @param visible true if this is a visible configuration
     * @return this configuration
     */
    Configuration setVisible(boolean visible);

        expect:
        succeeds ':resolvableConfigurations'
        reportsCompleteAbsenceOfResolvableConfigurations()
    }

    def "if only consumable configurations present, task reports complete absence"() {
        given:
        buildFile << """
            configurations.create("custom") {
                description = "My custom configuration"

        """
        file("producer/build.gradle") << """
            configurations {
                dependencyScope("runtimeOnly")
                dependencyScope("implementation")
                consumable("runtimeElements") {
                    attributes.attribute(Attribute.of("attr1", Named), objects.named(Named,"value"))
                    extendsFrom(runtimeOnly, implementation)
                }
            }

include::sample[dir="snippets/dependencyManagement/definingUsingConfigurations-inheritance/groovy",files="build.gradle[tags=configuration-definition]"]
====

[[sec:resolvable-consumable-configs]]
== Resolvable and consumable configurations

Configurations are a fundamental part of dependency resolution in Gradle.

For more information, see the sections on <<declaring_dependencies.adoc#sec:what-are-dependency-configurations,dependency configurations>> as well as <<declaring_dependencies.adoc#sec:resolvable-consumable-configs,resolvable and consumable configurations>>.

NOTE: The word "configuration" is an overloaded term and has a different meaning outside of the context of dependency management.

[[sub:terminology_dependency]]
== Dependency

            if (hasLegacyConfigs) {
                message("Re-run this report with the '--all' flag to include legacy " + spec.getReportedTypeAlias() + "s (legacy = consumable and resolvable).");
            }
        } else {
            writeResults(data, nonLegacyConfigs);
        }
    }