}
            }
        }

        buildFile << """
            dependencies {
                conf("org:producer:1.0")
            }
        """

        when:
        repositoryInteractions {
            'org:producer:1.0' {
                expectResolve()
            }
            'org:transitive:1.0' {
                expectResolve()
            }
        }
        run ':checkDeps'

        buildFile << """
            dependencies {
                conf 'org:notfound:1.0'
            }
        """

        when:
        repositoryInteractions {
            'org:notfound:1.0' {
                expectGetMetadataMissing()
            }
        }

        then:
        fails 'checkDeps'
    }

            }
        }

        buildFile << """
            dependencies {
                conf('org:bar:1.0')
            }
        """

        when:
        repositoryInteractions {
            'org:foo:1.0' {
                expectResolve()
            }
            'org:bar:1.0' {
                expectResolve()
            }
        }
        succeeds 'checkDeps'

            dependencies.components.all(com.example.AddVariantRule)
        """

        then: "the variant added by the rule should be present and should be chosen as the resolution result"
        repositoryInteractions {
            group("org") {
                module("a") {
                    version("1") {
                        expectGetMetadata()
                        allowAll()
                    }

        """

        when:
        supplierInteractions.expectGetMetadata('org', 'testA') // one network request for A
        supplierInteractions.expectGetMetadata('org', 'testB') // and one for B
        repositoryInteractions {
            // only the resolved modules are going to get their metadata files fetched (for variant matching)
            // and no additional network request is performed because we got the attributes from the same

        }
    }

    def expectChainInteractions(repoTypes, chain, testVariant = 'api', configuration = null) {
        String prevRepoType = null
        chain.each { repoType ->
            repositoryInteractions(repoType) {
                "org:$repoType:1.0" {
                    expectGetMetadata()
                    expectGetArtifact()
                }
                "org:$repoType-api-dependency:1.0" {

        }
    }

    void repository(@DelegatesTo(RemoteRepositorySpec) Closure<Void> spec) {
        spec.delegate = repoSpec
        spec()
    }

    void repositoryInteractions(HttpRepository.MetadataType metadataType = getRepositoryMetadataType(),
                                @DelegatesTo(RemoteRepositorySpec) Closure<Void> spec) {
        RemoteRepositorySpec.DEFINES_INTERACTIONS.set(true)

        def align = new AlignmentSpec()
        spec.delegate = align
        spec.resolveStrategy = Closure.DELEGATE_FIRST
        spec()
        repositoryInteractions {
            align.applyTo(repoSpec)
        }
    }

    static class AlignmentSpec {
        final List<ModuleAlignmentSpec> specs = []
        final Set<String> skipsPlatformMetadata = []

                implementation("com.acme.foo:lib:1.1")
            }
        """
        resolve = new ResolveTestFixture(buildFile, "compileClasspath")
        resolve.prepare()

        repositoryInteractions {
            'com.acme.foo' {
                'core' {
                    '1.0' {
                        expectGetMetadata()
                    }
                    '1.1' {

    }

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