daemon << [false, true]
    }

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

                            module.pom.expectHead()
                        } else if (module instanceof IvyModule) {
                            module.ivy.expectHead()
                        }
                    }
                    if (gradleMetadataWasPublished) {
                        module.moduleMetadata.expectHead()
                    }
                    break

        server.expectGetMissing(getPath(), credentials)
    }

    @Override
    void expectGetRevalidate() {
        server.expectGetRevalidate(getPath(), file)
    }

    void expectHead() {
        server.expectHead(getPath(), file)
    }

    void expectHeadMissing() {
        server.expectHeadMissing(getPath())
    }

    void expectHeadBroken() {
        server.expectHeadBroken(path)
    }

            .createVerifyTaskModuleComponentIdentifier()

        // TODO - should make a single request
        module.pom.expectGetMissing()
        module.pom.expectGetMissing()
        module.artifact.expectHead()

        then:
        checkArtifactsResolvedAndCached()
    }

    @ToBeFixedForConfigurationCache
    def "updates artifacts for module #condition"() {
        given:

        server = new BlockingHttpServer(1000)
    }

    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)

            task remote(type: Sync) {
                into 'remote'
                from configurations.remote
            }
        """

        when:
        remote.pom.expectGet()
        remote.artifact.expectHead()
        remote.artifact.expectGet()

        run("remote")

        then:
        file("remote").assertHasDescendants("remote-1.0.aar")
        file('remote/remote-1.0.aar').assertIsCopyOf(remote.artifactFile)

                    vendor = JvmVendorSpec.matching("exotic")
                }
            }
        """

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

    @Shared String cachedDistributionHash;

    @Rule
    BlockingHttpServer server = new BlockingHttpServer()

    def configureServer(boolean expectHead) {
        if (expectHead) {
            server.expect(server.head("/gradle-bin.zip"))
        }
        server.expect(server.get("/gradle-bin.zip").sendFile(distribution.binDistribution))
        server.start()
    }

        module.publishWithChangedContent()

        and:
        server.resetExpectations()
        module.ivy.expectHead()
        module.ivy.sha1.expectGet()
        module.ivy.expectGet()
        sourceArtifact.expectHead()
        sourceArtifact.sha1.expectGet()
        sourceArtifact.expectGet()

        then:
        executer.withArgument(execArg)

        when:
        // No changes
        server.resetExpectations()
        m1.pom.expectHead()
        m1.artifact.expectHead()
        m2.metaData.expectHead()
        // TODO - these should not be required for unique versions
        m2.pom.expectHead()
        m2.artifact.expectHead()

        succeeds ":app:resolve"

        then: