local {
                    directory = '$cacheDir'
                }
            }
        """

        buildFile << customTaskCode()

        expect:
        executer.withBuildCacheEnabled()
        succeeds("customTask")
        !localBuildCache.empty
    }

    def "can enable with settings.gradle"() {
        settingsFile << """
            gradle.startParameter.buildCacheEnabled = true

                    enabled = true
                    url = "$url"
                    push = $push
                    $credentials
                }
            }
        """
        executer.withBuildCacheEnabled()

        when:
        succeeds("help")

        then:
        def result = result()

        result.remoteEnabled
        !result.localEnabled

                    enabled = true
                    directory = '${cacheDir.absoluteFile.toURI().toString()}'
                    push = true
                }
            }
        """
        executer.withBuildCacheEnabled()

        when:
        succeeds("help")

        then:
        def result = result()

        result.enabled
        result.localEnabled
        !result.remoteEnabled

        writeJavaSourceWithUnixLineEndings()

        when:
        executer.withBuildCacheEnabled()
        succeeds compileTask

        then:
        executedAndNotSkipped compileTask

        when:
        writeJavaSourceWithWindowsLineEndings()
        succeeds "clean"

        and:
        executer.withBuildCacheEnabled()
        succeeds compileTask

        then:
        fromCache compileTask
    }

            apply plugin: InMemoryBuildCachePlugin
        """

        when:
        executer.withBuildCacheEnabled()
        succeeds "compileJava", "--info"

        then:
        executed ":compileJava"

        expect:
        succeeds "clean"

        when:
        executer.withBuildCacheEnabled()
        succeeds "compileJava"

        then:
        skipped ":compileJava"
    }

        def enablingCode = by == EnabledBy.PROGRAMMATIC ? """\ngradle.startParameter.buildCacheEnabled = true\n""" : ""
        if (by == EnabledBy.INVOCATION_SWITCH) {
            executer.beforeExecute {
                withBuildCacheEnabled()
            }
        }

        def mainCache = new TestBuildCache(file("main-cache"))
        def buildSrcCache = new TestBuildCache(file("buildSrc-cache"))

    def localCache = new TestBuildCache(file("local-cache"))
    def cacheOperations = new BuildCacheOperationFixtures(executer, temporaryFolder)

    def setup() {
        executer.beforeExecute { withBuildCacheEnabled() }
        settingsFile << localCache.localCacheConfiguration()
    }

    def "cached origin metadata is correct"() {
        file("input.txt") << "data"

        buildFile << """

        settingsFile << """
            buildCache {
                remote(TestBuildCache)
            }
        """
        when:
        executer.withBuildCacheEnabled()
        fails("compileJava")
        then:
        failure.assertHasCause("Build cache type 'TestBuildCache' has not been registered.")
    }

        outputOrigin.originId(taskPath)
    }

    OriginMetadata origin(String taskPath) {
        outputOrigin.origin(taskPath)
    }

    def setup() {
        executer.beforeExecute {
            it.withBuildCacheEnabled()
        }
    }

    def "exposes origin build id when reusing cached outputs"() {
        given:
        buildScript """
            apply plugin: "base"

        """

        settingsFile << localCache.localCacheConfiguration() << remoteCache.remoteCacheConfiguration()

        executer.beforeExecute { it.withBuildCacheEnabled() }
    }

    def "remote loads are cached locally"() {
        given:
        settingsFile << """
            buildCache { local.push = false }
        """

        when:
        succeeds("t")