}

    /**
     * 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) {}

    /**

        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:

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

    // operations in general because we do not support snapshotting them.
    //
    // TODO(b/112837194): This restriction can be lifted with some work.
    bool allow_stack_ops = false;

    // Whether TensorArray operations are allowed.  We avoid auto-clustering
    // TensorArray operations in general because we do not support snapshotting
    // them.
    //

        Supplier<T> readFromDisk
    ) {
        return virtualFileSystem.findSnapshot(location)
            .map(snapshotProcessor)
            // Avoid snapshotting the same location at the same time
            .orElseGet(() -> producingSnapshots.guardByKey(location,
                () -> virtualFileSystem.findSnapshot(location)
                    .map(snapshotProcessor)

        snapshot.children.every { it.accessType == AccessType.VIA_SYMLINK }
        unfilteredSubsnapshots == [snapshot]
        0 * _
    }

    @Requires(UnitTestPreconditions.FilePermissions)
    def "snapshotting unreadable #type fails"() {
        given:
        def rootDir = tmpDir.createDir("root")
        rootDir.file('readableFile').createFile()
        rootDir.file('readableDirectory').createDir()

        // `input/marker`. So we don't trigger a rebuild.
        exitsContinuousBuildSinceNotWatchingAnyLocationsExceptForConfigCache()
    }

    def "does not detect changes when no snapshotting happens (#description)"() {
        given:
        def markerFile = file("input/marker")
        buildFile << """
            task myTask {
              def inputFile = file("input/marker")

 * if found correct.</li>
 * <li>If the workspace is inconsistent (the output hashes stored in {code metadata.bin} do not match
 * the hashes taken by snapshotting the current outputs), the workspace is moved to a temporary
 * location and we fall back to re-executing the work.</li>
 * <li>If we end up executing the work (either because there is no existing immutable workspace, or it is

        try {
            return checksumService.hash(file, kind.getAlgorithm()).toString();
        } catch (Exception e) {
            LOGGER.debug("Error while snapshotting " + file, e);
            return null;
        }
    }

    private static void resolveAllConfigurationsAndForceDownload(Project project) {
        ((ProjectInternal) project).getOwner().applyToMutableState(p ->