return isContentUpToDate(other) && metadata.equals(((RegularFileSnapshot) other).metadata);
    }

    @Override
    public boolean isContentUpToDate(FileSystemLocationSnapshot other) {
        if (!(other instanceof RegularFileSnapshot)) {
            return false;
        }
        return contentHash.equals(((RegularFileSnapshot) other).contentHash);
    }

    @Override

        result == filteredOutputs
        0 * _
    }

    private static RegularFileSnapshot fileSnapshot(String name, HashCode contentHash) {
        new RegularFileSnapshot("/absolute/${name}", name, contentHash, DefaultFileMetadata.file(0L, 0L, FileMetadata.AccessType.DIRECT))
    }

    private static FileSystemLocationSnapshot directorySnapshot(RegularFileSnapshot... contents) {
        def builder = MerkleDirectorySnapshotBuilder.sortingRequired()

 * limitations under the License.
 */

package org.gradle.internal.fingerprint.hashing;

import org.gradle.internal.snapshot.RegularFileSnapshot;

import java.util.function.Supplier;

public interface RegularFileSnapshotContext {
    Supplier<String[]> getRelativePathSegments();

    RegularFileSnapshot getSnapshot();

            this.content = content;
        }
    }

    enum FallbackStrategy {
        FULL_HASH() {
            @Nullable
            @Override
            HashCode handle(RegularFileSnapshot fileSnapshot, IoFunction<RegularFileSnapshot, HashCode> function) {
                try {
                    return function.apply(fileSnapshot);
                } catch (Exception e) {

import org.gradle.internal.hash.TestHashCodes
import org.gradle.internal.snapshot.RegularFileSnapshot
import spock.lang.Specification

class CachingResourceHasherTest extends Specification {
    def delegate = Mock(ResourceHasher)
    def path = "some"
    def snapshotterCacheService = Mock(ResourceSnapshotterCacheService)

        def root = temporaryFolder.createFile("root")
        def regularFileSnapshot = new RegularFileSnapshot(root.absolutePath, root.name, TestHashCodes.hashCodeFrom(1234), DefaultFileMetadata.file(5, 1234, AccessType.DIRECT))

        expect:
        filteredPaths(regularFileSnapshot, include("different")) == [] as Set
        filteredPaths(regularFileSnapshot, include(root.name)) == [root] as Set
    }

import org.gradle.internal.fingerprint.hashing.RegularFileSnapshotContext;
import org.gradle.internal.snapshot.RegularFileSnapshot;

import java.util.function.Supplier;

public class DefaultRegularFileSnapshotContext implements RegularFileSnapshotContext {
    private final Supplier<String[]> relativePathSegmentSupplier;
    private final RegularFileSnapshot snapshot;

import org.gradle.api.tasks.util.PatternFilterable
import org.gradle.internal.Factory
import org.gradle.internal.snapshot.FileSystemSnapshot
import org.gradle.internal.snapshot.RegularFileSnapshot
import org.gradle.test.fixtures.file.TestFile
import org.gradle.test.fixtures.file.TestNameTestDirectoryProvider
import org.junit.Rule
import spock.lang.Specification

import javax.annotation.Nullable

import org.gradle.internal.snapshot.FileSystemLocationSnapshot.FileSystemLocationSnapshotVisitor;
import org.gradle.internal.snapshot.FileSystemSnapshot;
import org.gradle.internal.snapshot.RegularFileSnapshot;
import org.gradle.internal.snapshot.SnapshotVisitResult;

import java.io.Closeable;
import java.io.File;
import java.io.IOException;

        def outputFileSnapshot = new RegularFileSnapshot(outputFile.absolutePath, outputFile.name, TestHashCodes.hashCodeFrom(234), DefaultFileMetadata.file(15, 234, FileMetadata.AccessType.DIRECT))
        def fileSnapshots = [
            outputDir: new DirectorySnapshot(outputDir.getAbsolutePath(), outputDir.name, FileMetadata.AccessType.DIRECT, TestHashCodes.hashCodeFrom(456), [