}
        """
        when:
        withBuildCache().run "customTask"
        then:
        result.assertTaskNotSkipped(":customTask")

        when:
        file("buildSrc/build").deleteDir()
        file("buildSrc/.gradle").deleteDir()
        cleanBuildDir()

        withBuildCache().run "customTask"
        then:

                }
            }
        """

        when:
        withBuildCache().run("createFile", "-Dfile.encoding=$fileEncoding")
        then:
        output.contains("> Default charset: $fileEncoding")
        executedAndNotSkipped(":createFile")

        when:
        assert outputFile.delete()
        withBuildCache().run("createFile", "-Dfile.encoding=$fileEncoding")
        skipped(":createFile")

                outputs.cacheIf { true }
                doFirst {
                    file("second.txt").text = "Hello from the second task"
                }
            }
        """

        when:
        withBuildCache().run "first", "second"
        then:
        executedAndNotSkipped(":first", ":second")
        file("first.txt").text == "Hello from the first task"
        file("second.txt").text == "Hello from the second task"
    }

        buildFile << """
            apply plugin: "java"
        """
        file("src/main/java/Main.java") << """
            public class Main {}
        """

        when:
        withBuildCache().run "assemble"
        then:
        outputContains "Loading "
        outputContains "Storing "
    }

    def "produces deprecation message when BuildCacheKey.getDisplayName() is called"() {

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

    }

    @Override
    boolean existsBuildCacheEntry(String key) {
        cacheDir.file(key).exists()
    }

    @Override
    AbstractIntegrationSpec withEnabledBuildCache() {
        withBuildCache()
    }

        when:
        withWatchFs().withBuildCache().run("localStateTask", "outputFileTask")
        then:
        executedAndNotSkipped(":localStateTask", ":outputFileTask")
        localStateOutputFile.exists()

        when:
        localStateOutputFile.delete()
        waitForChangesToBePickedUp()
        withWatchFs().withBuildCache().run("localStateTask", "outputFileTask")
        then: