VersionNumber.parse("1-rc1-SNAPSHOT") == new VersionNumber(1, 0, 0, "rc1-SNAPSHOT")
        VersionNumber.parse("1.2-rc1-SNAPSHOT") == new VersionNumber(1, 2, 0, "rc1-SNAPSHOT")
        VersionNumber.parse("1.2.3-rc1-SNAPSHOT") == new VersionNumber(1, 2, 3, "rc1-SNAPSHOT")

        VersionNumber.parse("1.rc1-SNAPSHOT") == new VersionNumber(1, 0, 0, "rc1-SNAPSHOT")

    MavenHttpModule snapshot

    @Override
    List<MavenHttpModule> getModulesInReadOnlyCache(MavenHttpRepository repo) {
        [
            snapshot = repo.module("org.module", "core", "1.0-SNAPSHOT"),
        ]
    }

    def "latest version is fetched from writable cache"() {
        given:
        def latest = snapshot.publishWithChangedContent()
        buildFile << """

import org.gradle.internal.serialize.SerializerSpec
import org.gradle.internal.snapshot.CompositeFileSystemSnapshot
import org.gradle.internal.snapshot.DirectorySnapshot
import org.gradle.internal.snapshot.FileSystemSnapshot
import org.gradle.internal.snapshot.MissingFileSnapshot
import org.gradle.internal.snapshot.RegularFileSnapshot
import org.gradle.internal.snapshot.TestSnapshotFixture

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

    /**

        FileSystemLocationSnapshot snapshot = snapshotSupplier.get();
        storeIfUnchanged(absolutePath, versionBefore, snapshot);
        return snapshot;
    }

    @Override
    public <T> T store(String baseLocation, StoringAction<T> storingAction) {
        long versionBefore = versionHierarchyRoot.getVersion(baseLocation);
        return storingAction.snapshot(snapshot -> {

                    : temporaryFolder.file(it)
            }
            def snapshot = snapshotter.snapshot(TestFiles.fixed(files)).snapshot
            builder.put(propertyName, snapshot)
        }
        return builder.build()
    }

    FileSystemLocationSnapshot snapshot(File file) {
        snapshotter.snapshot(TestFiles.fixed(file)).snapshot as FileSystemLocationSnapshot
    }

                    } else {
                        return SnapshotVisitResult.CONTINUE;
                    }
                } else {
                    fingerprint = fingerprint(stringInterner.intern(relativePath.toRelativePath()), snapshot.getType(), snapshot);
                }

                if (fingerprint != null) {
                    builder.put(absolutePath, fingerprint);

        when:
        def test1TokensFileSnapshot = test1TokenFile.snapshot()
        def test1LexerFileSnapshot = test1LexerFile.snapshot()
        def test1ParserFileSnapshot = test1ParserFile.snapshot()

        def test2TokensFileSnapshot = test2TokenFile.snapshot()
        def test2LexerFileSnapshot = test2LexerFile.snapshot()
        def test2ParserFileSnapshot = test2ParserFile.snapshot()

        changedGrammar("Test2")

        then:

        this.includeExtensions = includeExtensions
    }

    private List<File> snapshot = []

    // Executes optional operation and makes a snapshot of outputs (sets the last modified timestamp to zero for all files)
    public <T> T snapshot(Closure<T> operation = null) {
        T result = operation?.call()
        snapshot.clear()
        targetDir.eachFileRecurse(FileType.FILES) {
            if (isIncluded(it)) {

        int number = 0;

        Versioning versioning = metadata.getVersioning();
        if (versioning != null) {
            Snapshot snapshot = versioning.getSnapshot();
            if (snapshot != null && snapshot.getBuildNumber() > 0) {
                number = snapshot.getBuildNumber();
            }
        }

        return number;
    }