where:
        first             | second
        "consumable"      | "resolvable"
        "consumable"      | "dependencyScope"
        "resolvable"      | "consumable"
        "resolvable"      | "dependencyScope"
        "dependencyScope" | "consumable"
        "dependencyScope" | "resolvable"
    }

    /**
     * A consumable dependency scope that will become a consumable configuration in the next major version.
     */
    @SuppressWarnings("deprecation")
    public static final ConfigurationRole CONSUMABLE_DEPENDENCY_SCOPE_TO_CONSUMABLE = difference(ConfigurationRoles.CONSUMABLE_DEPENDENCY_SCOPE, ConfigurationRoles.CONSUMABLE);

    /**
     * All known migration roles.
     */

        'attributes(Action)'                           | 'dependencyScope' | "attributes { attribute(Attribute.of('foo', String), 'bar') }" || [ProperMethodUsage.CONSUMABLE, ProperMethodUsage.RESOLVABLE]
        'defaultDependencies(Action)'                  | 'consumable'      | 'defaultDependencies { }'                                      || [ProperMethodUsage.DECLARABLE_AGAINST]

     */
    private static ConfigurationRole createNonDeprecatedRole(String name, boolean consumable, boolean resolvable, boolean declarable) {
        return new DefaultConfigurationRole(name, consumable, resolvable, declarable, false, false, false);
    }

    private static final Set<ConfigurationRole> ALL = ImmutableSet.of(
        LEGACY, CONSUMABLE, RESOLVABLE, RESOLVABLE_DEPENDENCY_SCOPE, CONSUMABLE_DEPENDENCY_SCOPE, DEPENDENCY_SCOPE
    );

    private final String name;
    private final boolean consumable;
    private final boolean resolvable;
    private final boolean declarable;
    private final boolean consumptionDeprecated;
    private final boolean resolutionDeprecated;
    private final boolean declarationDeprecated;

    public DefaultConfigurationRole(
        String name,
        boolean consumable,
        boolean resolvable,
        boolean declarable,

        expect:
        fails 'help'
        assertUsageLockedFailure('conf', type)

        where:
        createCode                     | type
        "consumable('conf')"           | 'Consumable'
        "consumable('conf') { }"       | 'Consumable'
        "resolvable('conf')"           | 'Resolvable'
        "resolvable('conf') { }"       | 'Resolvable'
        "dependencyScope('conf')"      | 'Dependency Scope'

     *
     * @param isConsumable whether the configuration is consumable
     * @param isResolvable whether the configuration is resolvable
     * @param isDeclarable whether the configuration is declarable
     * @param isConsumptionDeprecated whether the configuration's consumable behavior is deprecated

    }

    def "can not find unknown usage combinations consumable=#consumable, resolvable=#resolvable, declarable=#declarable"() {
        expect:
        !ConfigurationRoles.byUsage(consumable, resolvable, declarable).isPresent()

        where:
        consumable  | resolvable    | declarable
        false       | false         | false
        true        | true          | false

        }
    }

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

    }

    void doesNotHaveLegacyLegend() {
        outputDoesNotContain("(l) Legacy or deprecated configuration. Those are variants created for backwards compatibility which are both resolvable and consumable.")
    }

    void hasIncubatingLegend() {