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

buildscript {
    $repositories

    dependencies {
        classpath "org:foo:1.0"
    }
}
plugins {
    id('base')
}
"""

        when:
        mod.ivy.expectGet()
        mod.artifact.expectGet()

        run 'buildEnvironment'

        then:
        outputContains("org:foo:1.0")

        where:
        inSettings  | notation
        true        | "excludeGroup('org')"

            if (module instanceof MavenModule) {
                switch (it) {
                    case InteractionExpectation.GET:
                        module.rootMetaData.expectGet()
                        break
                    case InteractionExpectation.HEAD:
                        module.rootMetaData.expectHead()
                        break

        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'

    }

    private static void expectRefresh(MavenHttpModule module) {
        module.pom.expectHead()
        module.pom.sha1.expectGet()
        module.moduleMetadata.expectHead()
        module.moduleMetadata.sha1.expectGet()
        module.artifact.expectHead()
        module.artifact.sha1.expectGet()
    }

    private void exposeServerToContainers() {
        GradleInContainer.exposeHostPort(server.port)
    }

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

        when: "platform isn't resolved"
        succeeds ":help"

        then:
        noExceptionThrown()

        when:
        module.pom.expectGet()
        module.moduleMetadata.expectGet()
        module.getArtifact(type: 'toml').expectGet()

        succeeds ':publish'

        then:
        expectPlatformContents 'composed-platform'
    }