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"() {

    }

    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]

     * <p>
     * This method is only intended for use for specific situations involving resolvable configuration, it is
     * <strong>NOT</strong> intended as a general-purpose copying mechanism.
     *
     * @implSpec Usage: This method should only be called on resolvable configurations and will emit a deprecation warning if

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

    }
    // endregion Role-Based Configurations

        expect:
        succeeds("resolve")
    }

        when:
        def conf1 = dependencyScope("conf1")
        def conf2 = dependencyScope("conf2")
        def conf3 = dependencyScope("conf3", [conf1, conf2])
        resolvable("child1", [conf3])
        resolvable("child2", [conf1])
        resolvable("other")

        conf1.getDependencies().add(dependency1)
        conf2.getDependencies().add(dependency2)
        conf3.getDependencies().add(dependency3)

 *                                   "resolvable" : true|false,
 *                                   "hasConflict" : true|false,
 *                                   "children": [
 *                                       {
 *                                           "name" : "...",
 *                                           "resolvable" : "...",
 *                                           "hasConflict" : true|false,

            }
        """

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

        then:
        result.groupedOutput.task(":resolvableConfigurations").assertOutputContains("""--------------------------------------------------