'org:testA:1.0' {
                expectGetMetadata()
            }
            'org:testB:1.0' {
                expectGetMetadata()
            }
        }
        fails ":checkDeps"

        then:

        failure.assertHasCause(error)

        where:
        rule                               | error

        """

        file("platform/build.gradle") << """
            plugins {
                id 'java-platform'
            }

        """

        when:
        succeeds ':checkDeps'

        then:
        resolve.expectGraph {
            root(":", ":depsub:") {
                edge('org:lib:1.0', ':platform', 'depsub:platform:') {
                    variant(expectedVariant, [

                    }
                }
            }
        """
        file("dep/build.gradle") << blueAndRedVariants()

        when:
        run ':checkDeps'

        then:
        resolve.expectGraph {
            root(":", ":test:") {
                project(':dep', "test:dep:unspecified") {
                    variant "${color}Variant", [color: color]

            }
        }

        then:
        succeeds 'checkDeps'

        when:
        resetExpectations()
        repositoryInteractions {
            'group:projectB:1.1' {
                expectResolve()
            }
        }

        then:
        executer.withArgument("-Pstatus=integration")
        succeeds 'checkDeps'
    }

                            }
                        }
                    }
                }
                failOnVersionConflict()
            }
"""

        when:
        run "checkDeps"

        then:
        resolve.expectGraph {
            root(":", ":depsub:") {
                module("org.stuff:foo:2.0") {
                    edge("org.utils:api:1.5", "org.utils:api:1.5") {

                }
            }
            dependencies {
                components {
                    all(WrongRule)
                }
            }
        """

        expect:
        fails 'checkDeps'
        resolve.assertFailurePresent(failure)
        failure.assertHasFileName("Build file '$buildFile.path'")
        failure.assertHasLineNumber(lines + 3)

        """
        buildFile << """
            plugins {
                id 'java-library'
            }

            group = 'org.gradle.lib'
            version = '1.0'

            task checkDeps {
                def runtimeClasspath = configurations.runtimeClasspath
                doLast {
                    println("Resolved: \${runtimeClasspath.files.name.join(', ')}")
                }
            }

                api "org:foo"
            }
        """
        checkConfiguration("compileClasspath")

        when:
        module.pom.expectGet()
        module.artifact.expectGet()

        run ":checkDeps"

        then:
        resolve.expectGraph {
            root(":", "org.test:test:1.9") {
                project(":platform", "org.test:platform:1.9") {

        m.moduleMetadata.expectGet()
        m.artifact.expectGet()

        when:
        run("checkDeps")

        then:
        resolve.expectGraph {
            root(":", ":test:") {
                module("test:a:1.2")
            }
        }

        when:
        server.resetExpectations()
        run("checkDeps")

        then:
        resolve.expectGraph {
            root(":", ":test:") {

            'org:test:1.0'()
        }

        when:
        repositoryInteractions {
            'org:test:1.0' {
                expectGetMetadata()
            }
        }
        fails ':checkDeps'

        then:
        failure.assertHasCause("Could not resolve org:test:1.0: Resolution strategy disallows usage of changing versions")
    }

    def "fails to resolve a transitive changing dependency"() {