}
            it.publish()
        }
        def deps = new StringBuilder()
        StringBuilder queries = new StringBuilder()
        roModules.each {
            expectResolve(it)
            it.metaData.allowGetOrHead()
            it.rootMetaData.allowGetOrHead()
            deps.append("""                implementation '${it.group}:${it.module}:${resolveDynamic ? '+' : it.version}'
""")

                expectGetMetadata()
            }
            'org.test:module:1.2' {
                expectGetMetadata()
            }
            'org.test:module:1.1' {
                expectResolve()
            }
        }

        then:

        run ':checkDeps'
        resolve.expectGraph {
            root(":", ":test:") {

            }
        """

        when:
        repository {
            'org.test:projectA:1.1'()
        }
        repositoryInteractions {
            'org.test:projectA:1.1' {
                expectResolve()
            }
        }

        then:
        succeeds ":checkDeps"
        resolve.expectGraph {
            root(":", ":test:") {
                module("org.test:projectA:1.1")
            }

                expectVersionListing()
                '1.2' {
                    expectGetMetadata()
                }
                '1.1' {
                    expectResolve()
                }
                '1.0' {
                    expectResolve()
                }
            }
        }

        then:
        succeeds "verify"

        when:
        resetExpectations()

                expectVersionListing()
            }
            'org.test:module:1.2' {
                expectGetMetadata()
            }
            'org.test:module:1.1' {
                expectResolve()
            }
        }

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

            def missedVersions = misses
            spec.group(group) {
                module(moduleName) {
                    if (alignedTo) {
                        version(alignedTo) {
                            expectResolve()
                        }
                    }
                    otherVersions.each {
                        version(it) {
                            expectGetMetadata()
                        }

    }

    dependencies {
        classpath 'org:bar:1.0'
    }
}
    Class.forName('org.gradle.MyClass')
"""

        repositoryInteractions {
            'org:bar:1.0' {
                expectResolve()
            }
        }
        when:
        fails()

        then:
        failure.assertHasCause("org.gradle.MyClass")
    }

    private void createJarFile(TestFile jar) {

                variant("default", ['some':'other'])
                expectGetMetadata()
                expectGetArtifact()
            }
            'org.test:moduleB:1.0' {
                expectResolve()
            }
        }

        then:
        succeeds 'checkDep'
        def expectedVariant = variantToTest
        resolve.expectGraph {
            root(':', ':test:') {

${triedMetadata('org.utils', 'api', '2.1', false)}
Required by:
""")

        when:
        resetExpectations()
        repositoryInteractions {
            'org.utils:api:2.1' {
                expectResolve()
            }
        }

        then:
        succeeds ":checkDeps"
    }

    def "reports broken module when component selection rule requires meta-data"() {
        buildFile << """

    }
}

dependencies {
    components {
        all(PomRule)
    }
}
"""
        when:
        repositoryInteractions {
            'org.test:projectA:1.0' {
                expectResolve()
            }
        }

        then:
        succeeds 'resolve'
        succeeds 'resolve'
    }

    def 'rule cache properly differentiates inputs'() {
        repository {