By default, `resolvableConfigurations` prints information about all purely resolvable configurations.
These are configurations that are marked resolvable but *not* marked consumable.
Though some resolvable configurations are also marked consumable, these are legacy configurations that should *not* have dependencies added in build scripts.

    }

    def "mainSourceElements can be consumed by another task via Dependency Management"() {
        buildFile << """
            plugins {
                id 'java'
            }

            // A resolvable configuration to collect source data
            def sourceElementsConfig = configurations.create("sourceElements") {
                visible = true
                assert canBeResolved
                canBeConsumed = false

                        config.getDependencies().add(project.getDependencies().create(project));
                    });

                    NamedDomainObjectProvider<Configuration> resolvable = configurations.register("resolvable", config -> {
                        config.setCanBeConsumed(false);
                        config.setCanBeResolved(true);
                        config.extendsFrom(dependencyScope.get());

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

    private void writeResults(ConfigurationReportModel data, List<ReportConfiguration> configs) {

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

    /**
     * Creates a new locked resolvable configuration instance.
     */
    DefaultResolvableConfiguration createResolvable(
        String name,
        ConfigurationsProvider configurationsProvider,

                super.visitErrorResolvedQualifier(errorResolvedQualifier)
            }

            private fun processErrorNameReference(resolvable: FirResolvable) {
                val nameReference = resolvable.calleeReference as? FirErrorNamedReference ?: return
                val name = nameReference.unresolvedName ?: return
                unresolvedNames += name
            }

        !forbidden(alternatives)    || errorOutput.contains("Resolving dependency configuration '$configuration' is not allowed as it is defined as 'canBeResolved=false'.\nInstead, a resolvable ('canBeResolved=true') dependency configuration that extends '$configuration' should be resolved.")

        """

        when:
        fails("helloWorld")

        then:
        failureDescriptionContains("could not resolve plugin artifact 'foo:bar:1.0'")
    }

    def "succeeds build for resolvable custom artifact"() {
        given:
        buildScript helloWorldPlugin('0.2')

        settingsFile << """
            pluginManagement {
                resolutionStrategy {

                compilation("first")
            }}
        """

        buildFile << """
            configurations {
                dependencyScope("someConf")
                resolvable("resolvableConf") {
                    extendsFrom(someConf)
                }
            }

            firstChildComponent.withVariantsFromConfiguration(configurations.firstRuntimeElements) {

    public static final String ENFORCED_API_ELEMENTS_CONFIGURATION_NAME = "enforcedApiElements";
    public static final String ENFORCED_RUNTIME_ELEMENTS_CONFIGURATION_NAME = "enforcedRuntimeElements";

    // Resolvable configurations
    public static final String CLASSPATH_CONFIGURATION_NAME = "classpath";

    private static final String DISALLOW_DEPENDENCIES = "Adding dependencies to platforms is not allowed by default.\n" +