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

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

        assert '\u20AC'.charAt(0) == 0x20AC
    }
}
""", "ISO-8859-15")
        assert scriptFile.getText("ISO-8859-15") != scriptFile.getText("UTF-8")
        server.expectGet('/script.gradle', scriptFile).contentType("text/plain; charset=ISO-8859-15")

        and:
        buildFile << "apply from: '${server.uri}/script.gradle'"

        expect:
        succeeds 'check'
    }

                    doLast { println path + " " + files*.name }
                }
            }
            resolveConf.dependsOn(':impl:resolveConf')
        """

        when:
        lib.ivy.expectGet()
        lib.jar.expectGet()
        run "resolveConf"

        then:
        output.contains ':impl:resolveConf [lib-1.0.jar]'
        output.contains ':resolveConf [lib-1.0.jar]'
    }

                '1.2'()
            }
        }
        // We are resolving with `gradleMetadata()` metadata: always use a directory listing (and not maven-metadata.xml)
        repository.directoryList('org.test', 'projectA').expectGet()
        repositoryInteractions(HttpRepository.MetadataType.ONLY_GRADLE) {
            'org.test:projectA' {

                '1.2' {
                    expectResolve()
                }
            }
        }

    }

    URI start() {
        server.start()
        server.uri(archiveName)
    }

    void reset() {
        expectHead()
        expectGet()
    }

    void expectHead() {
        server.expect(server.head(archiveName))
    }

    void expectGet() {
        server.expect(server.get(archiveName, { e ->
            e.sendResponseHeaders(200, 0)
            IOUtils.copy(archiveFile, e.getResponseBody())

        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'
            }

                }
            }
        """

        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 "uses #type proxy to access remote build script plugin"() {
        given:
        testProxyServer.start(userName, password)

        def script = file('external.gradle')
        server.expectGet('/external.gradle', script)

        script << """
            task doStuff
            assert buildscript.sourceFile == null
            assert "${server.uri}/external.gradle" == buildscript.sourceURI as String
"""

        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