}

    /**
     * This is a temporary measure for Gradle tasks to track a legacy measurement of all input snapshotting together.
     */
    default void markLegacySnapshottingInputsStarted() {}

    /**
     * This is a temporary measure for Gradle tasks to track a legacy measurement of all input snapshotting together.
     */
    default void markLegacySnapshottingInputsFinished(CachingState cachingState) {}

    /**

        0 * _

        then:
        result.valueSnapshots as Map == ["identity": inputSnapshot]
        result.fileFingerprints as Map == [:]
    }

    def "reports value snapshotting problem"() {
        def failure = new RuntimeException("Error")
        def input = "failing-value"

        when:
        fingerprintInputProperties { visitor ->

        file("b/src/main/${language.name}/Bar.${language.name}") << 'class Bar { public void useFoo(Foo foo) { } }'

        when:
        // Run with --debug to ensure that class snapshotting didn't fail.
        succeeds ":b:${language.compileTaskName}", "--debug"

        then:
        executedAndNotSkipped(":b:${language.compileTaskName}")

        when:

import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

/**
 * Attached to an input property to specify that line endings should be normalized
 * when snapshotting inputs. Two files with the same contents but different line endings
 * will be considered equivalent.
 *
 * Line ending normalization is only supported with ASCII encoding and its supersets (i.e.

import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

/**
 * Attached to an input property to specify that directories should be ignored
 * when snapshotting inputs. Files within directories and subdirectories will be
 * snapshot, but the directories themselves will be ignored. Empty directories,
 * and directories that contain only empty directories will have no effect on the

        result.assertTasksSkipped(":$spec.copyTask")

        where:
        spec << DefaultExcludesFixture.specs()
    }

    def "default excludes defined in build#scriptLanguage are ignoring for snapshotting"() {
        given:
        def configurationCache = newConfigurationCacheFixture()
        def spec = new DefaultExcludesFixture.Spec(
            Collections.singletonList(new DefaultExcludesFixture.RootBuildLocation()),

            snapshot >> outputSnapshot
        }
        0 * _

        then:
        result as Map == ["output": outputSnapshot]
    }

    def "reports snapshotting problem"() {
        def failure = new UncheckedIOException(new IOException("Error"))

        when:
        outputSnapshotter.snapshotOutputs(work, workspace)

        then:

        'resources directory' | 'RESOURCES' | 'resources/main'    | 'processResources' | 'compileJava'
    }

    @Issue("gradle/gradle#1347")
    def "compile classpath snapshotting ignores non-relevant elements"() {
        def buildFileWithDependencies = { String... dependencies ->
            buildFile.text = """
                apply plugin: 'java'

                ${mavenCentralRepository()}

                outputFile = file("classes.jar")
            }
        """

        // This is to make sure that:
        //   - The snapshotting of the zip task finishes after the outputs have been broadcast by the compile task
        //   - The snapshotting of the zip task finishes before the snapshotting of the outputs of the compile task
        server.expectConcurrent("zipFileSnapshottingStarted", "compileAction1")

        run("generate")

        then:
        result.assertTaskNotSkipped(":generate")
        output.count("checking") == 22 // checked twice, once to snapshot and once when the task action runs. Should be memoized when snapshotting
        outputContains("checking a/a.txt")
        outputContains("checking d/d.txt")
        file("out.txt").text == "a.txt,c.txt,d.txt"
    }