try {
            return normalizedContentHasher.hash(snapshot);
        } catch (IOException e) {
            throw new UncheckedIOException(failedToNormalize(snapshot), e);
        } catch (UncheckedIOException e) {
            throw new UncheckedIOException(failedToNormalize(snapshot), e.getCause());
        }
    }

        source api: ["class A {}"]
        source impl: ["class B { public A a;}"]
        source app: ["class Unrelated {}", "class C { public B b; }"]
        app.snapshot {
            impl.snapshot {
                run language.compileTaskName
            }
        }

        when:
        file("api/src/main/${language.name}/A.${language.name}").delete()

    public String getValue() {
        return value;
    }

    @Override
    public ValueSnapshot snapshot(@Nullable Object value, ValueSnapshotter snapshotter) {
        ValueSnapshot snapshot = snapshotter.snapshot(value);
        if (equals(snapshot)) {
            return this;
        }
        return snapshot;
    }

    @Override
    public boolean equals(Object obj) {
        if (obj == this) {

import org.gradle.internal.snapshot.DirectorySnapshot;
import org.gradle.internal.snapshot.FileSystemLeafSnapshot;
import org.gradle.internal.snapshot.FileSystemLocationSnapshot;
import org.gradle.internal.snapshot.MissingFileSnapshot;
import org.gradle.internal.snapshot.RegularFileSnapshot;
import org.gradle.internal.snapshot.RelativePathTracker;
import org.gradle.internal.snapshot.SnapshottingFilter;

        buildFile << """
            dependencies {
                conf "org:foo:1.0-SNAPSHOT"
                conf "org:bar:1.0"
            }
        """

        when:
        // looks for the Maven pom file because it's a snapshot
        snapshotModule.metaData.expectGet() // gets the maven-metadata.xml file to get the latest snapshot version
        snapshotModule.pom.expectGet()
        snapshotModule.artifact.expectGet()

            DirectorySnapshotBuilder.EmptyDirectoryHandlingStrategy.INCLUDE_EMPTY_DIRS
        )
        children.each { snapshot ->
            if (snapshot instanceof DirectorySnapshot) {
                builder.visitDirectory(snapshot)
            } else {
                builder.visitLeafElement(snapshot)
            }
        }
        return builder.leaveDirectory()
    }

        executer.withTasks("jar").run();

        TestFile jar = file("build/libs/project.jar");
        jar.assertIsFile();
        TestFile.Snapshot snapshot = jar.snapshot();

        executer.withTasks("jar").run();

        jar.assertHasNotChangedSince(snapshot);

        sleep 1000 // Some filesystems (ext3) have one-second granularity for lastModified, so bump the time to ensure we can detect a regenerated file

        this.relativePathSegmentSupplier = relativePathSegmentSupplier;
        this.snapshot = snapshot;
    }

    @Override
    public Supplier<String[]> getRelativePathSegments() {
        return relativePathSegmentSupplier;
    }

    @Override
    public RegularFileSnapshot getSnapshot() {
        return snapshot;
    }

        def same = new MavenUniqueSnapshotComponentIdentifier(moduleIdentifier, "1.0-SNAPSHOT", "timestamp")
        def differentVersion = new MavenUniqueSnapshotComponentIdentifier(moduleIdentifier, "1.1-SNAPSHOT", "timestamp")
        def differentTimestamp = new MavenUniqueSnapshotComponentIdentifier(moduleIdentifier, "1.0-SNAPSHOT", "other")

        then:

        module.allowAll()

        and: "We resolve dependencies"
        run 'retrieve'

        then:
        file('libs').assertHasDescendants('unique-1.0-SNAPSHOT.jar')
        def snapshot = file('libs/unique-1.0-SNAPSHOT.jar').snapshot()

        when:
        module.publishWithChangedContent()

        and: "We resolve again, offline"
        server.resetExpectations()