"""

        when:
        lib1.pom.expectGet()
        lib1.artifact.expectGet()
        lib2.pom.expectGet()
        lib2.artifact.expectGet()
        lib3.pom.expectGet()
        lib3.artifact.expectGet()

        lib4.pom.expectGet()
        lib4.artifact.expectGet()
        lib5.pom.expectGet()
        lib5.artifact.expectGet()

        then:
        run ':checkDeps'

        module(pluginId, pluginId + PLUGIN_MARKER_SUFFIX, pluginVersion).with {
            pom.expectGet()
            artifact.expectGet()
            allowAll()
        }
        module(group, artifactId, version).with {
            pom.expectGet()
            artifact.expectGet()
            allowAll()
        }
    }

    @Override

    }

    void expectPut(PasswordCredentials credentials) {
        expectPut(200, credentials)
    }

    void expectPut(String username, String password) {
        server.expectPut(getPath(), username, password, getFile())
    }

    void expectPut(Integer statusCode = 200, PasswordCredentials credentials = null) {
        server.expectPut(getPath(), getFile(), statusCode, credentials)
    }

    abstract void expectHeadMissing()

    abstract void expectHeadRevalidate()

    abstract void expectPut()

    abstract void expectPutBroken()

    @Override
    void expectDownload() {
        expectGet()
    }

    @Override
    void expectDownloadBroken() {
        expectGetBroken()
    }

    @Override
    void expectDownloadMissing() {
        expectGetMissing()

            }
        """
        def configurationCache = newConfigurationCacheFixture()

        remoteRepo.getModuleMetaData("thing", "lib").expectGet()
        v3.pom.expectGet()
        v3.artifact.expectGet()

        when:
        configurationCacheRun("resolve1")

        then:
        configurationCache.assertStateStored()
        outputContains("result = [lib-1.3.jar]")

        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()
    }

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

                }
            }
        """

        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