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

    def "withType works for factory methods before declaration in Groovy DSL"() {

     */
    public static final ConfigurationRole RESOLVABLE = createNonDeprecatedRole("Resolvable", false, true, false);

    /**
     * Meant as a temporary solution for situations where we need to declare dependencies against a resolvable configuration.
     *
     * These situations should be updated to use a separate dependency scope configuration for declaring dependencies and extend it with a separate resolvable configuration.
     */
    @Deprecated

     *
     * @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
     * @param isResolutionDeprecated whether the configuration's resolvable behavior is deprecated

    }

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

    void hasIncubatingLegend() {

    }

    def "creates resolvable configurations"() {
        expect:
        verifyRole(ConfigurationRoles.RESOLVABLE, "a") {
            resolvable("a")
        }
        verifyRole(ConfigurationRoles.RESOLVABLE, "b") {
            resolvable("b", {})
        }
        verifyUnlocked(ConfigurationRoles.RESOLVABLE, "c") {
            resolvableUnlocked("c")
        }

        json.project.configurations[0].dependencies[0].children[0].name == "foo:qix:1.0"
        json.project.configurations[0].dependencies[0].children[0].resolvable == 'FAILED'
        json.project.configurations[0].dependencies[1].name == "grr:bzz:1.0"
        json.project.configurations[0].dependencies[1].resolvable == 'FAILED'
    }

    def "conflicting dependencies are marked as such"() {
        given:

        'getSyntheticDependencies()'       | 'consumable'      | "getSyntheticDependencies()"            || [ProperMethodUsage.RESOLVABLE]
        'getSyntheticDependencies()'       | 'dependencyScope' | "getSyntheticDependencies()"            || [ProperMethodUsage.RESOLVABLE]
        'callAndResetResolutionState()'    | 'consumable'      | "callAndResetResolutionState { 'foo' }" || [ProperMethodUsage.RESOLVABLE]

    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,
        boolean consumptionDeprecated,

    private final ComponentIdentifier actual;
    private final boolean resolvable;
    private final Set<RenderableDependency> children = new LinkedHashSet<>();

    public RequestedVersion(ComponentSelector requested, ComponentIdentifier actual, boolean resolvable) {
        this.requested = requested;
        this.actual = actual;
        this.resolvable = resolvable;
    }

    public void addChild(DependencyEdge child) {

    /**
     * A resolvable dependency scope that will become a resolvable configuration in the next major version.
     */
    @SuppressWarnings("deprecation")
    public static final ConfigurationRole RESOLVABLE_DEPENDENCY_SCOPE_TO_RESOLVABLE = difference(ConfigurationRoles.RESOLVABLE_DEPENDENCY_SCOPE, ConfigurationRoles.RESOLVABLE);

    /**