}
        metadataDownloads.times {
            module.rootMetaData.expectGet()
        }
        metadataChecksumDownloads.times {
            module.rootMetaData.sha1.expectGet()
        }
        module.rootMetaData.expectPublish(isGradle6Plus)

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

        m1.pom.expectGet()
        m1.artifact.expectGetMissing()

        def m2 = mavenHttpRepo.module('org', 'broken-artifact', '1.0').publish()
        m2.pom.expectGet()
        m2.artifact.expectGetBroken()

        def m3 = mavenHttpRepo.module('org', 'found', '2.0').publish()
        m3.pom.expectGet()
        m3.artifact.expectGet()

        expect:

        run 'useCompileConfiguration'

        then:
        server.resetExpectations()

        when:
        // Expect downloads when task executed
        module.pom.expectGet()
        module.artifact.expectGet()
        run 'useCompileConfiguration'

        then:
        executed ":child:jar", ":useCompileConfiguration"
    }

    @ToBeFixedForConfigurationCache

                }
            }
        """

        file("src/main/java/Foo.java") << "public class Foo {}"

        server.expectHead("/path/toolchain.zip", toolchainArchive)
        server.expectGet("/path/toolchain.zip", toolchainArchive)

        when:
        failure = executer
                .withTasks("compileJava")
                .requireOwnGradleUserHomeDir("needs to be able to provision fresh toolchains")

        def resourceFile = file("web-file.txt")
        def keyStore = TestKeyStore.init(resource.dir)
        keyStore.enableSslWithServerCert(server)
        keyStore.configureServerCert(executer)

        server.expectGet("/myConfig-${uuid}.txt", resourceFile)
        server.start()

        buildFile << """
            task uriText(type: MyTask) {
                config = resources.text.fromUri("${server.uri}/myConfig-${uuid}.txt")

        super(server)
        this.directory = directory
        this.path = path
        this.server = server
    }

    @Override
    public void expectGet() {
        server.expectGetDirectoryListing(path, directory)
    }

    public void allowGet() {
        server.allowGetDirectoryListing(path, directory)
    }

    @Override

        when:
        server.expectGet("/cache/${key.hashCode}", config.credentials.username, config.credentials.password, destFile)
        def result = null
        cache.load(key) { input ->
            result = input.text
        }
        then:
        result == 'Old'
        server.authenticationAttempts == ['Basic'] as Set

                    compile("test:snapshot:1.2-SNAPSHOT")
                }
            }
        """

        when:
        m1.pom.expectGet()
        m1.artifact.expectGet()
        m2.metaData.expectGet()
        m2.pom.expectGet()
        m2.artifact.expectGet()

        succeeds ":app:resolve"

        then:
        output.count("files: [changing-1.2.jar.txt, snapshot-1.2-SNAPSHOT.jar.txt]") == 1

        """

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

        then:
        succeeds ':compileJava'

        when:
        markForArtifactCacheCleanup()

        then:
        succeeds ':help'

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

        then:
        succeeds ':compileJava'

        projectFModuleMissing.missing()
        def projectF2 = getMavenHttpRepo("/repo2").module('group', 'projectF', '2.0').publish()
        projectF2.pom.expectGet()
        projectF2.artifact.expectGet()

        initSettingsFile()

        buildFile << """
            allprojects {
                apply plugin:'java-library'
            }