import org.gradle.util.internal.TextUtil

import static org.gradle.testkit.runner.TaskOutcome.FAILED
import static org.gradle.testkit.runner.TaskOutcome.FROM_CACHE
import static org.gradle.testkit.runner.TaskOutcome.SKIPPED
import static org.gradle.testkit.runner.TaskOutcome.SUCCESS
import static org.gradle.testkit.runner.TaskOutcome.UP_TO_DATE

/**
 * Tests the behavior of a task with a FROM_CACHE result
 */
@NonCrossVersion

            #include MY_HEADER
"""

        and:
        outputs.snapshot { run "mainExecutable" }

        when:
        run "mainExecutable"
        then:
        skipped compileTask
    }

    @ToBeFixedForConfigurationCache
    def "does not recompile when included header has the same name as a directory"() {
        given:
        buildFile << """
model {

    /**
     * Asserts that exactly the given set of tasks have been skipped.
     */
    ExecutionResult assertTasksSkipped(Object... taskPaths);

    /**
     * Asserts the given task has been skipped.
     */
    ExecutionResult assertTaskSkipped(String taskPath);

    /**
     * Asserts that exactly the given set of tasks have not been skipped.
     */
    ExecutionResult assertTasksNotSkipped(Object... taskPaths);

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

        then:
        skipped taskName

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

        then:
        skipped taskName
    }

    void setupProjectWithJavaAgentIn(TestFile directory) {
        setupProjectIn(directory)

        // Work around some bugs in Input.skip()
        int remaining = input.limit() - input.position();
        if (remaining == 0) {
            long skipped = inputStream.skip(count);
            if (skipped > 0) {
                extraSkipped += skipped;
            }
            return skipped;
        } else if (count <= remaining) {
            input.setPosition(input.position() + (int) count);
            return count;
        } else {

import static org.gradle.testkit.runner.TaskOutcome.FAILED
import static org.gradle.testkit.runner.TaskOutcome.FROM_CACHE
import static org.gradle.testkit.runner.TaskOutcome.NO_SOURCE
import static org.gradle.testkit.runner.TaskOutcome.SKIPPED
import static org.gradle.testkit.runner.TaskOutcome.SUCCESS
import static org.gradle.testkit.runner.TaskOutcome.UP_TO_DATE

/**
 * Tests more intricate aspects of the BuildResult object
 */
@InspectsExecutedTasks

        then:
        executedAndNotSkipped ':compileJava'

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

        then:
        skipped ':compileJava'

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

        then:
        skipped ':compileJava'
    }

    def "outputs loaded from the cache are snapshotted as outputs"() {
        buildFile << """
            apply plugin: 'base'

        runWork()

        then: 'it is skipped because UP-TO-DATE'
        result.assertTaskSkipped ':runWork'
        outputContains ':runWork UP-TO-DATE'

        and:
        outputDoesNotContain expectedOutput

        when: 'the outputs are deleted'
        file('build').deleteDir()

        and: 'task runs for the 3rd time'
        runWork()

        then: 'it is skipped because FROM-CACHE'

        final available = isToolChainAvailable(annotation)
        spec.skipped |= !available
    }

    @Override
    void visitFeatureAnnotation(RequiresInstalledToolChain annotation, FeatureInfo feature) {
        final available = isToolChainAvailable(annotation)
        feature.skipped |= !available
    }

    private static boolean isToolChainAvailable(RequiresInstalledToolChain annotation) {

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

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

        then:
        skipped ":cacheable"
    }

    def "task is cacheable after previous failure"() {
        buildFile << """
            task foo {
                def outFile = project.file("out.txt")
                outputs.file(outFile)