@Singleton
public class DefaultModelResolver implements ModelResolver {

    @Override
    public ModelSource resolveModel(
            Session session, String groupId, String artifactId, String version, Consumer<String> resolvedVersion)
            throws ModelResolverException {
        try {
            ArtifactCoordinate coord = session.createArtifactCoordinate(groupId, artifactId, version, "pom");

        String resolvedVersion = resolvedComponentVersions.get(
            moduleIdentifierFactory.module(group, name)
        );

        if (resolvedVersion == null) {
            return null;
        }

        return ResolvedCoordinates.create(group, name, resolvedVersion);
    }

        def resolvedFile = resolvedFiles.get(0)
        assert resolvedFile.startsWith('foo-')
        assert resolvedFile.endsWith('.jar')
        def resolvedVersion = (resolvedFile =~ /\d+/).getAt(0)
        resolvedVersion
    }

            }"""

        when:
        run 'retrieve'

        then:
        file('build').assertHasDescendants('projectA-1.0.jar', 'projectB-1.0.jar', "projectC-${resolvedVersion}.jar")

        where:
        versionDefinition | resolvedVersion
        "RELEASE"         | "2.0"
        "LATEST"          | "2.1-SNAPSHOT"
    }

    public static class MyModelResolver implements ModelResolver {
        @Override
        public ModelSource resolveModel(
                Session session, String groupId, String artifactId, String version, Consumer<String> resolvedVersion)
                throws ModelResolverException {
            String id = groupId + ":" + artifactId + ":" + version;
            if (id.startsWith("org.sonatype.mavenbook.multi:parent:")) {

    ModelSource resolveModel(
            @Nonnull Session session,
            @Nonnull String groupId,
            @Nonnull String artifactId,
            @Nonnull String version,
            @Nonnull Consumer<String> resolvedVersion)
            throws ModelResolverException;

        if (resolvedVersions.isEmpty()) {
            Assume.assumeFalse("Ignore the test if all baseline versions are filtered out in Historical Performance Test", ResultsStoreHelper.isHistoricalChannel())
        }

        assert !resolvedVersions.isEmpty(): "No versions selected: ${versions}"

        resolvedVersions
    }

        String cacheKey = constraintCacheKey(repository, constraint);
        return resolvedVersions.get(cacheKey);
    }

    public void putWorkingDirForSelector(VersionControlRepositoryConnection repository, VersionConstraint constraint, File workingDir) {
        String cacheKey = constraintCacheKey(repository, constraint);
        resolvedVersions.put(cacheKey, workingDir);
    }

        request.setLocalRepository(localRepository);
        request.setRemoteRepositories(remoteRepositories);
        return resolveVersion(artifact, request);
    }

    protected String resolveVersion(Artifact artifact, RepositoryRequest request)
            throws RepositoryMetadataResolutionException {
        RepositoryMetadata metadata;
        // Don't use snapshot metadata for LATEST (which isSnapshot returns true for)

                }
            }
        """
    }

    def taskWhichResolves(lib, resolveVersion) {
        return """
            configurations {
                testartifacts
            }

            dependencies {
                testartifacts 'org.gradle.test:${lib}:${resolveVersion}'
            }

            task ${resolveTask}(type: Copy) {
                dependsOn ":publish"