archiveBaseName = "wrong"
            }
            task firstZip(type: Zip) {
                archiveBaseName = "first"
            }

            configurations {
                consumable("blah") {
                    attributes {
                        attribute(Attribute.of('custom', String), "foo")
                        attribute(Attribute.of('attr', String), "incorrect")
                    }

        }
    }

    @Override
    public void setAllowedUsageFromRole(ConfigurationRole role) {
        if (isCanBeConsumed() != role.isConsumable()) {
            setCanBeConsumedInternal(role.isConsumable());
        }
        if (isCanBeResolved() != role.isResolvable()) {
            setCanBeResolvedInternal(role.isResolvable());
        }

          - Provides flavor 'free' but the consumer didn't ask for it""")
    }

    def "does not select default configuration when no configurations with attributes and default configuration is not consumable"() {
        given:
        createDirs("a", "b")
        file('settings.gradle') << "include 'a', 'b'"
        buildFile << """
            $typeDefs

            project(':a') {

    }

    void "deprecations are passed to copies when corresponding role is #baseRole"() {
        ConfigurationRole role = new DefaultConfigurationRole("test", baseRole.consumable, baseRole.resolvable, baseRole.declarable, true, true, true)
        def configuration = prepareConfigurationForCopyTest(conf("conf", ":", ":", role))
        def resolutionStrategyCopy = Mock(ResolutionStrategyInternal)

These configurations were deprecated for consumption and are now no longer consumable.
Attempting to consume them will result in an error.

==== Identical consumable configurations are now an error

If a project has multiple consumable configurations that share the same attributes and capabilities declaration, the build will fail when publishing or resolving as a dependency that project.

* Resolvable configurations should not have their resolution strategy, dependencies, hierarchy, etc. modified after they have been resolved.
* Consumable configurations should not have their dependencies, hierarchy, attributes, etc. modified after they have been published or consumed as a variant.

            }
        """

        when:
        executer.expectDeprecationWarning('(l) Legacy or deprecated configuration. Those are variants created for backwards compatibility which are both resolvable and consumable.')
        run ':outgoingVariants', '--all'

        then:
        result.groupedOutput.task(":outgoingVariants").assertOutputContains("""--------------------------------------------------
Variant legacy (l)

The plugin declares a consumable `binaryTestResultsElements` configuration that represents the binary test results of the `test` task.

Executing this command line will cause Gradle to:

* resolve all <<declaring_dependencies.adoc#sec:resolvable-consumable-configs,resolvable configurations>>, which includes:
** configurations from the root project
** configurations from all subprojects
** configurations from `buildSrc`
** included builds configurations

     * </p>
     *
     * @return The name of this project. Never return null.
     */
    String getName();

    /**
     * Returns a human-consumable display name for this project.
     */
    String getDisplayName();

    /**
     * Returns the description of this project, if any.
     *
     * @return the description. May return null.
     */