private final String hash;
            private final Set<String> attributes;
            private final List<Entry> roots = new ArrayList<>();

            public Property(String hash, Set<String> attributes) {
                this.hash = hash;
                this.attributes = attributes;
            }

            public String getHash() {
                return hash;
            }

import org.gradle.internal.cc.impl.initialization.ConfigurationCacheStartParameter
import org.gradle.internal.buildtree.BuildActionModelRequirements
import org.gradle.internal.hash.Hasher
import org.gradle.internal.hash.Hashing
import org.gradle.internal.service.scopes.Scope
import org.gradle.internal.service.scopes.ServiceScope
import org.gradle.util.GradleVersion
import org.gradle.util.internal.GFileUtils.relativePathOf

        }
        if (shouldUseFromCache(original)) {
            final HashCode contentHash = snapshot.getHash();
            if (!seen.add(contentHash)) {
                // Already seen an entry with the same content hash, ignore it
                return empty();
            }
            // It's a new content hash, transform it
            return Optional.of(

        this.rootHashes = rootHashes;
    }

    @Override
    public HashCode getHash() {
        if (hash == null) {
            Hasher hasher = Hashing.newHasher();
            hashingStrategy.appendToHasher(hasher, fingerprints.values());
            hash = hasher.hash();
        }
        return hash;
    }

    @Override
    public boolean isEmpty() {

        }
        ImmutableListMultimap.Builder<String, HashCode> builder = ImmutableListMultimap.builder();
        roots.accept(snapshot -> {
            builder.put(snapshot.getAbsolutePath(), snapshot.getHash());
            return SnapshotVisitResult.SKIP_SUBTREE;
        });
        return builder.build();
    }

    /**
     * For a {@link RegularFileSnapshot} returns the file length, otherwise {@code 0}.

            SourceFileState sourceFileState = entry.getValue();
            fileSerializer.write(encoder, entry.getKey());
            hashSerializer.write(encoder, sourceFileState.getHash());
            encoder.writeBoolean(sourceFileState.isHasUnresolved());
            encoder.writeSmallInt(sourceFileState.getEdges().size());
            for (IncludeFileEdge includeFileState : sourceFileState.getEdges()) {

    /**
     * The hash of the snapshot.
     *
     * This makes it possible to uniquely identify the snapshot.
     * <dl>
     *     <dt>Directories</dt>
     *     <dd>The combined hash of the children, calculated by appending the name and the hash of each child to a hasher.</dd>
     *     <dt>Regular Files</dt>
     *     <dd>The hash of the content of the file.</dd>
     *     <dt>Missing files</dt>

    @TempDir
    File tempDir

    def "calculates hash for text file with #description"() {
        def file = file('foo') << contents
        def delegate = Mock(LineEndingNormalizingFileSystemLocationSnapshotHasher)
        def hasher = LineEndingNormalizingFileSystemLocationSnapshotHasher.wrap(delegate, LineEndingSensitivity.NORMALIZE_LINE_ENDINGS)

        when:
        hasher.hash(snapshot(file))

        then:
        0 * delegate._

        HashCode hash = resourceHasher.hash(zipEntryContext);
        if (hash != null) {
            fingerprints.add(new DefaultFileSystemLocationFingerprint(zipEntryContext.getFullName(), FileType.RegularFile, hash));
        }
    }

    private DefaultFileSystemLocationFingerprint newZipMarker(String relativePath) {

                SourceFileState state = incrementalCompilation.getFinalState().getState(sourceFile);
                final HashCode hash = state.getHash();
                List<String> headers = new ArrayList<>();
                for (IncludeFileEdge edge : state.getEdges()) {
                    if (hash.equals(edge.getIncludedBy())) {
                        headers.add(edge.getIncludePath());
                    }
                }