}

    @Override
    public ValueSnapshot snapshot(@Nullable Object value, ValueSnapshotter snapshotter) {
        PrimitiveType valueType = PrimitiveType.maybeOfValue(value);
        if (primitiveType == valueType && primitiveType.equals(array, value)) {
            return this;
        }
        ValueSnapshot snapshot = snapshotter.snapshot(value);
        if (snapshot.equals(this)) {
            return this;
        }

        inputFile.text = 'content'
        succeeds "b"

        then:
        result.assertTasksNotSkipped(":a", ":b")

        when:
        TestFile.Snapshot aSnapshot = outputFileA.snapshot()
        TestFile.Snapshot bSnapshot = outputFileB.snapshot()

        then:
        outputFileA.text == '[content]'
        outputFileB.text == '[[content]]'

        // No changes
        when:

            return new ExternalResourceName(rootUri, path);
        }

        /**
         * Return the location of the snapshot `maven-metadata.xml`, which contains details of the latest published snapshot for a Maven module.
         */
        ExternalResourceName getSnapshotMetadataLocation() {

        }
        if (stage != null && gradleVersion.stage == null) {
            return -1;
        }

        Long thisSnapshot = snapshot == null ? Long.MAX_VALUE : snapshot;
        Long theirSnapshot = gradleVersion.snapshot == null ? Long.MAX_VALUE : gradleVersion.snapshot;

        if (thisSnapshot.equals(theirSnapshot)) {
            return version.compareTo(gradleVersion.version);
        } else {

            ArtifactRepository localRepository)
            throws RepositoryMetadataStoreException {
        // TODO this could be a lot nicer... should really be in the snapshot transformation?
        if (metadata.isSnapshot()) {
            Metadata prevMetadata = metadata.getMetadata();

            for (ArtifactRepository repository : previousMetadata.keySet()) {

            if (artifact.isSnapshot()) {
                Matcher matcher = Artifact.VERSION_FILE_PATTERN.matcher(artifact.getVersion());
                if (matcher.matches()) {
                    Snapshot snapshot = new Snapshot();
                    snapshot.setTimestamp(matcher.group(2));
                    try {
                        snapshot.setBuildNumber(Integer.parseInt(matcher.group(3)));

        snapshotter.snapshot("abc") == snapshotter.snapshot(isolated)
        snapshotter.snapshot("other") != snapshotter.snapshot(isolated)
    }

    def "creates snapshot for integer"() {
        expect:
        def snapshot = snapshotter.snapshot(123)
        snapshot instanceof IntegerValueSnapshot
        snapshot == snapshotter.snapshot(123)
        snapshot != snapshotter.snapshot(-1)
        snapshot != snapshotter.snapshot(123L)

        // Here, we need to determine which policy to use. Release updateInterval will be used when
        // the metadata refers to a release artifact or meta-version, and snapshot updateInterval will be used when
        // it refers to a snapshot artifact or meta-version.
        // NOTE: Release metadata includes version information about artifacts that have been released, to allow

        )
        newChild.snapshot.get().type == FileType.Directory

        addedNodes == [newGrandChild]
        removedNodes.empty

        1 * snapshot.asFileSystemNode() >> newGrandChild
        _ * newGrandChild.snapshot >> Optional.of(snapshot)
        _ * selectedChild.snapshot >> Optional.empty()
        1 * snapshot.type >> fileType
        interaction { noMoreInteractions() }

import org.gradle.internal.snapshot.DirectorySnapshot
import org.gradle.internal.snapshot.FileSystemLocationSnapshot
import org.gradle.internal.snapshot.MissingFileSnapshot
import org.gradle.internal.snapshot.RegularFileSnapshot
import org.gradle.internal.snapshot.SnapshotUtil
import org.gradle.internal.snapshot.SnapshotVisitorUtil
import org.gradle.internal.snapshot.SnapshottingFilter