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
    }

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

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

        """
    }

    private void startBuild(String task, boolean buildCacheEnabled) {
        executer.withArgument('--debug').withTasks(task)
        if (buildCacheEnabled) {
            executer.withBuildCacheEnabled()
        }

        client = new DaemonClientFixture(executer.start())
        waitForDaemonLog(START_UP_MESSAGE)
        daemons.daemon.assertBusy()
    }

                    shouldFail = System.getProperty("failOn")
                    push = true
                }
            }
        """

        executer.beforeExecute {
            executer.withBuildCacheEnabled()
        }
    }

    def "remote cache #failEvent error stack trace is printed when requested (#showStacktrace)"() {
        // Need to do it like this because stacktraces are always enabled for integration tests

    def buildOperations = new BuildOperationsFixture(executer, temporaryFolder)
    def cacheOperations = new BuildCacheOperationFixtures(buildOperations)

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

    @ToBeFixedForConfigurationCache(skip = INVESTIGATE)
    def "fails build when packing archive fails"() {
        when: