'org:testA:1' {
                expectResolve()
            }
            'org:testB:2' {
                expectResolve()
            }
        }

        then:
        succeeds 'checkDeps'

        and:
        outputContains "Listing versions for module testA"
        outputContains "Listed [3, 2, 1] for org:testA"
        outputContains "Supplying metadata for module org:testA:3"

            }
        """
        def resolve = new ResolveTestFixture(buildFile)
        resolve.prepare()

        when:
        mod.pom.expectGet()
        succeeds ":checkDeps"

        then:
        resolve.expectGraph {
            root(":", "org.gradle.bugs:test:1.9") {
                module("org:foo:1.0") {
                    variant("platform-runtime", [

                    }
                    '1.1' {
                        expectGetMetadata()
                    }
                }

            }
        }

        run ':checkDeps'

        then:
        resolve.expectGraph {
            root(":", ":consumer:") {
                edge('com.acme.foo:core:1.0', 'com.acme.foo:core:1.1') {
                    byConstraint("platform alignment")

        assert files.collect { it.name } == ['projectA-1.2.jar']
    }
}
"""
        resolve.prepare()

        when:
        executer.withArguments("--offline")

        then:
        fails 'checkDeps'

        and:
        resolve.assertFailurePresent(failure)
        failure.assertResolutionFailure(":compile")
            .assertHasCause('No cached version of org.name:projectA:1.2 available for offline mode')

        resolve = new ResolveTestFixture(buildFile, config)
        resolve.prepare()
        resolve.expectDefaultConfiguration("api")
        buildFile << """
            allprojects {
                tasks.named("checkDeps") {
                    def outputFile = rootProject.file("\${rootProject.buildDir}/${config}-files.txt")
                    def files = configurations.${config}
                    doLast {

        and:
        output.count('Configured buildB') == 1
    }

    void resolvedGraph(@DelegatesTo(ResolveTestFixture.NodeBuilder) Closure closure) {
        resolve.prepare()
        execute(buildA, ":checkDeps", buildArgs)
        resolve.expectGraph {
            root(":", "org.test:buildA:1.0", closure)
        }
    }

        buildArgs = args as List
    }

    private void checkDependencies() {
        resolve.prepare()
        execute(buildA, ":checkDeps", buildArgs)
    }

    private void checkDependenciesFails() {
        resolve.prepare()
        fails(buildA, ":checkDeps", buildArgs)
    }

    void checkGraph(@DelegatesTo(ResolveTestFixture.NodeBuilder) Closure closure) {
        resolve.expectGraph {

            }
        }
        '''
        resolve.prepare("compile")

        when:
        run 'checkDeps'

        then:
        resolve.expectGraph {
            root(":", ":nullsafe:1.0") {
                configuration("_classpath")
                artifact(name: "someDir", type: "", version: "")

        then:
        execute(buildA, ":buildC:dependencies")
    }

    void resolvedGraph(@DelegatesTo(ResolveTestFixture.NodeBuilder) Closure closure) {
        resolve.prepare()
        execute(buildA, ":checkDeps", buildArgs)
        resolve.expectGraph {
            root(":", "org.test:buildA:1.0", closure)
        }
    }

            .configuration('b', extendsFrom: ["parent"])
            .configuration('c', extendsFrom: ["b"])
            .publish()

        when:
        run ':checkDeps'

        then:
        resolve.expectGraph {
            root(":", "org.test:test:1.0") {
                module("ivy.configuration:projectA:1.2") {
                    configuration("a")