}), "/*", EnumSet.of(DispatcherType.REQUEST))

        settingsFile << withHttpBuildCacheServer()

        expect:
        withBuildCache().succeeds "compileJava"

        when:
        withBuildCache().run "clean"
        then:
        withBuildCache().succeeds "compileJava"
    }

    }

    def 'push to local'() {
        pushToLocal()

        when:
        withBuildCache().run cacheableTask

        then:
        executedAndNotSkipped(cacheableTask)
        cacheOperations.assertStoredToLocalCacheForTask(cacheableTask)
        remoteCache.empty

        when:
        pullOnly()
        withBuildCache().run 'clean', cacheableTask

        then:
        skipped(cacheableTask)

        when:
        withBuildCache().run(taskPath)

        then:
        cacheOperations.getCacheKeyForTaskOrNull(taskPath) == null

        when:
        withBuildCache().run("clean", "cacheable", "-PstoreInCache")

        then:
        listCacheFiles().any { it.name == cacheOperations.getCacheKeyForTask(taskPath) }

        when:
        withBuildCache().run("clean", "cacheable")

        then:

        def compiledScalaClass = scalaClassFile('UsesJava.class')

        when:
        withBuildCache().run ':compileJava', compilationTask

        then:
        compiledJavaClass.exists()
        compiledScalaClass.exists()

        when:
        withBuildCache().run ':clean', ':compileJava'

        then:
        skipped ':compileJava'

        when:

            }
        """
        when:
        withBuildCache().run "jacocoTestReport"
        then:
        executedAndNotSkipped ":test", ":jacocoTestReport"
        reportFile.assertIsFile()

        when:
        succeeds "clean"
        then:
        reportFile.assertDoesNotExist()

        when:
        withBuildCache().run("integrationTest", "jacocoIntegrationTestReport")
        and:

    abstract String getCompilationTask()
    abstract String getCompiledFile()

    def 'compilation can be cached'() {
        when:
        withBuildCache().run compilationTask

        then:
        compileIsNotCached()

        when:
        withBuildCache().succeeds 'clean', compilationTask

        then:
        compileIsCached()
    }

    @Issue("https://github.com/gradle/gradle/issues/12860")

        source("class A {}", "class B {}")
        withBuildCache().run language.compileTaskName
        def cachedBuild = outputs.snapshot {
            withBuildCache().run "clean", language.compileTaskName
        }
        cachedBuild.groupedOutput.task(":compileJava").outcome == "FROM_CACHE"

        when:
        source("class A { /* ${UUID.randomUUID()} */ }")
        withBuildCache().run language.compileTaskName, "--info"

        given:
        project_a_depends_on_project_b()

        when:
        withBuildCache().run 'assemble'

        then:
        executedAndNotSkipped ':b:jar'
        executedAndNotSkipped ':a:jar'

        when:
        make_abi_compatible_change_on_b()

        withBuildCache().run 'clean', 'assemble'

        then:
        executedAndNotSkipped ':b:jar'
        skipped ':a:compileJava'

        when:
        withBuildCache().run "customTask"

        then:
        count == 1
        httpBuildCacheServer.cacheDir.listFiles().size() == 1
    }

    def "transient error on read is retried"() {
        given:
        settingsFile << withHttpBuildCacheServer()
        withBuildCache().run "customTask"
        withBuildCache().run "clean"

        when:

        setupProject()
        def allCompileTasks = ['', ':hello', ':log'].collect { compileTask(it, buildType) } as String[]

        when:
        withBuildCache().run compileTask(buildType)

        then:
        executedAndNotSkipped allCompileTasks

        when:
        withBuildCache().run 'clean', installTask(buildType)

        then:
        skipped allCompileTasks