@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);
    }

        String resolvedVersion

        TestVariantDependencyResolver(@Nullable String resolvedVersion) {
            this.resolvedVersion = resolvedVersion
        }

        @Override
        ResolvedCoordinates resolveComponentCoordinates(ExternalDependency dependency) {
            if (resolvedVersion == null) {
                return null
            }

        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"
    }

            root(":", ":test:") {
                edge("org:foo:{strictly $directDependencyVersion}", "org:foo:$resolvedVersion")
                edge("org:bar:1.0", "org:bar:1.0") {
                    edge("org:foo:$transitiveDependencyVersion", "org:foo:$resolvedVersion") {
                        if (transitiveDependencyVersion != resolvedVersion) {
                            byAncestor()
                        }

    }

    @Nullable
    private ModuleMetadataSpec.Version versionFor(
        ImmutableVersionConstraint versionConstraint,
        @Nullable String resolvedVersion
    ) {
        checker.sawDependencyOrConstraint();
        if (resolvedVersion == null && isEmpty(versionConstraint)) {
            return null;
        }
        checker.sawVersion();

        when:
        succeeds 'dependencies'

        then:
        outputContains("org:bar:latest.${level} -> $resolvedVersion")

        where:
        level         | resolvedVersion
        'release'     | '1.0'
        'integration' | '1.0-SNAPSHOT'
    }

    def "can write lock when using #version"() {

		})
		return
	}

	vr, ok := r.resolvedVersion[m.Path]
	if ok && vr.version != m.Version {
		reportConflict(q, m, vr)
		return
	}
	r.resolvedVersion[m.Path] = versionReason{m.Version, q}
	q.resolved = append(q.resolved, m)
}

// updateBuildList updates the module loader's global build list to be
// consistent with r.resolvedVersion, and to include additional modules

    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:")) {