}

            task checkDeps {
                def runtimeClasspath = configurations.runtimeClasspath
                doLast {
                    assert runtimeClasspath*.name == ['a.jar', 'external-1.0.jar', 'b.jar']
                }
            }
"""

        expect:
        succeeds ":checkDeps"
    }


    @Issue("GRADLE-3124")

            'a:a:1.0' { expectResolve() }
            'b:b:1.0' { expectResolve() }
        }

        and: // Initial request to cache metadata
        succeeds "checkDeps"

        when:
        server.resetExpectations()
        succeeds "checkDeps"

        then:
        resolve.expectGraph {
            root(":", ":test:") {
                module("a:a:1.0") {
                    module("b:b:1.0")

        """

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

        then:
        fails 'checkDeps'
    }

        latest.moduleMetadata.expectGet()
        latest.artifact.expectHead()
        latest.artifact.sha1.expectGet()
        latest.artifact.expectGet()

        succeeds ':checkDeps', '--refresh-dependencies'

        then:
        resolve.expectGraph {
            root(':', 'org.gradle:ro-test:20') {
                module('org.module:core:1.0-SNAPSHOT')
            }
        }

        latest.rootMetaData.allowGetOrHead()
        expectResolve(latest)
        if (resolveDynamic) {
            executer.withArgument("--refresh-dependencies")
        }

        succeeds ':checkDeps'

        then:
        resolve.expectGraph {
            root(':', 'org.gradle:ro-test:20') {
                edge('org.module:core:+', 'org.module:core:1.1')
            }
        }

        and:

        latest.moduleMetadata.expectGet()
        latest.artifact.expectHead()
        latest.artifact.sha1.expectGet()
        latest.artifact.expectGet()

        succeeds ':checkDeps', '--refresh-dependencies'

        then:
        resolve.expectGraph {
            root(':', 'org.gradle:ro-test:20') {
                snapshot('org.module:core:1.0-SNAPSHOT', latest.uniqueSnapshotVersion, '1.0-SNAPSHOT')

        this.buildFile = buildFile
        this.config = config
    }

    void prepare(String config = this.config) {
        buildFile << """
            allprojects {
                tasks.register("checkDeps") {
                    if (${GradleContextualExecuter.configCache}) {
                        def files = configurations.${config}
                        doLast {
                            files.forEach { }

        repositoryInteractions {
            id('org.test:module:1.0') {
                expectGetMetadata()
                expectGetArtifact()
            }
        }

        then:
        run ':checkDeps'
        resolve.expectGraph {
            root(":", ":test:") {
                module('org.test:module:1.0:customVariant2')
            }
        }
    }

        def m4 = mavenHttpRepo.module('org.foo', 'rock').dependsOn(m3).publish()

        m1.allowAll()
        m2.allowAll()
        m3.pom.expectGetBroken()
        m4.allowAll()

        when:
        fails "checkDeps"

        then:
        failedResolve.assertFailurePresent(failure)
        def op = operations.first(ResolveConfigurationDependenciesBuildOperationType)
        op.details.configurationName == "compileClasspath"

        withReadOnlyCache()
        other.allowAll()
        parent.allowAll()
        succeeds ':checkDeps'

        then:
        noExceptionThrown()
    }


    @Override
    List<MavenHttpModule> getModulesInReadOnlyCache(MavenHttpRepository repo) {