void taskIsNotCached(String task) {
        withBuildCache().run task
        executedAndNotSkipped(task)
        cleanBuildDir()

        withBuildCache().run task
        executedAndNotSkipped(task)
    }

    void taskIsCached(String task) {
        withBuildCache().run task
        executedAndNotSkipped(task)
        cleanBuildDir()

        withBuildCache().run task
        skipped(task)
    }

        """
        when:
        withBuildCache().run "unspecified"
        then:
        assertCachingDisabledFor NOT_ENABLED_FOR_TASK, "Caching has not been enabled for the task"
    }

    def "cacheability for a cacheable task is null"() {
        buildFile << """
            task cacheable(type: Cacheable) {}
        """
        when:
        withBuildCache().run "cacheable"
        then:

            application {
                mainClass = "Hello"
            }
        """
        withBuildCache().run "run"
        withBuildCache().run "clean"
        expect:
        withBuildCache().run "run"
    }

    def "tasks get cached when source code changes back to previous state"() {
        expect:
        withBuildCache().run "jar" assertTaskNotSkipped ":compileJava" assertTaskNotSkipped ":jar"

        when:

        when:
        withBuildCache().run(first, second)
        then:
        firstOutput.assertExists()
        secondOutput.assertExists()
        // Only the first task can be cached since the second detects the overlap
        assertTaskOutputCached(first)
        assertTaskOutputNotCached(second)

        when:
        cleanBuildDir()
        withBuildCache().run(first, second)
        then:

        setupProjectWithJavaAgentIn(relocatedDir)

        when:
        inDirectory(originalDir)
        withBuildCache().run taskName

        then:
        executedAndNotSkipped taskName

        and:
        outputContains('JavaAgent configured!')

        when:
        inDirectory(originalDir)
        withBuildCache().run taskName

        then:
        skipped taskName

        when:

                            attributes.attribute(color, 'blue')
                        }
                    }
                }
            }
        """

        when:
        withBuildCache().run ":consumer:resolve"

        then:
        executedAndNotSkipped(":consumer:resolve")

        result.groupedOutput.transform("MakeGreen")
            .assertOutputContains("processing [producer.jar]")

        executer.requireDaemon().requireIsolatedDaemons()

        when: "task is built in the original location"
        inDirectory(originalDir)
        executer.withJavaHome(originalJavaHome)
        withBuildCache().run taskName
        def originalResults = extractResultsFrom(originalDir)
        then: "it is executed and cached"
        executedAndNotSkipped taskName

        when: "task is re-executed without the cache"

        }

        when:
        executer.inDirectory(project1)
        withBuildCache().run 'myTask'

        then:
        executedAndNotSkipped(':myTask')
        project1.file('build/tmp/myTask/output.txt').text == "hello"

        when:
        executer.inDirectory(project2)
        withBuildCache().run 'myTask'

        then:
        skipped(':myTask')

    def "scaladoc is loaded from cache"() {
        classes.baseline()
        buildScript(classes.buildScript())

        when:
        withBuildCache().run scaladoc

        then:
        executedAndNotSkipped scaladoc

        when:
        succeeds "clean"
        withBuildCache().run scaladoc

        then:
        skipped scaladoc
    }

    def "scaladoc uses maxMemory"() {

            additionalData.asMap == [
                'typeName' : 'CustomTask',
            ]
        }

    }

    def "exposes file inputs, ignoring empty directories"() {
        given:
        withBuildCache()
        settingsFile << "include 'a', 'b'"
        createDir("a") {
            file("build.gradle") << "plugins { id 'java' }"
            dir("src/main/java") {
                file("A.java") << "class A {}"