implementation 'org.other:other:1.0'
            }
        """

        when:
        withReadOnlyCache()

        other.pom.expectGet()
        other.moduleMetadata.expectGet()
        other.artifact.expectGet()

        succeeds ':checkDeps'

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

                    }
                }
            }
        """

        m1.ivy.expectGet()
        m2.ivy.expectGet()
        m1.getArtifact(name: 'some-jar', type: 'jar').expectGet()

        expect:
        succeeds "resolve"
        // Currently builds all file dependencies

        when:
        module.pom.expectGet()
        sourceArtifact.expectHead()
        sourceArtifact.expectGet()

        then:
        succeeds 'verify'

        and:
        def jarFile = findFile(cacheDir, "files-*/**/example-1.0-sources.jar")

        when:
        assert jarFile.delete()
        server.resetExpectations()
        sourceArtifact.expectGet()

        then:

            type = 'jar'
        }
    }
}
"""
        resolve.prepare()

        when:
        dep.ivy.expectGet()
        dep.getArtifact(name: 'test-extra').expectGet()
        module2.ivy.expectGet()
        module2.jar.expectGet()

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

        """.stripIndent()
        when:
        projectB.pom.expectGet()
        projectB.artifact.expectGet()
        projectC.rootMetaData.expectGet()
        projectC.pom.expectGet()
        projectC.artifact.expectGet()

        projectD.pom.expectGet()
        projectD.metaData.expectGet()
        projectD.artifact.expectGet()

        and:
        def events = ProgressEvents.create()

        server.start()

        scriptUrl = "${server.uri}/${scriptName}"
        scriptFile = file("remote-script.gradle") << """
            println 'loaded remote script'
        """
        server.expectGet "/$scriptName", scriptFile

        buildFile << """
            apply from: '$scriptUrl'
            task ok
        """

        configurationCache = newConfigurationCacheFixture()
    }

                    println "Resolved: \${filesA} \${filesB} \${filesC}"
                }
            }
        """

        when:
        moduleA.pom.expectGet()
        moduleA.artifact.expectGet()
        moduleB.pom.expectGetBlocking()
        // No attempt made to get moduleC

        succeeds 'resolve'

        then:
        output.contains "Resolved: [a-1.0.jar] [] []"

        settingsFile << """
            rootProject.name = 'ro-test'
        """
    }

    MavenHttpModule expectResolve(MavenHttpModule module) {
        module.pom.expectGet()
        module.moduleMetadata.expectGet()
        module.artifact.expectGet()
        module
    }

    private void configureResolveTestFixture() {
        def config = 'compileClasspath'

        resolve = new ResolveTestFixture(buildFile, config)
        resolve.prepare()

        module.publish()
        module.pom.expectGet()
        module.moduleMetadata.expectGet()
        module.getArtifact(classifier: classifier).expectGet()
    }

    def "prefers standard JVM variant in Java projects"() {
        given:
        prepareResolve('compileClasspath', 'jre')

        when:

        module.artifact.expectPublish(false)
        module.pom.expectPublish(false)
        module.rootMetaData.expectGet()
        module.rootMetaData.sha1.expectGet()
        module.rootMetaData.expectGet()
        module.rootMetaData.sha1.expectGet()
        module.rootMetaData.expectPublish(false)

        settingsFile << 'rootProject.name = "publish"'
        buildFile << """