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)

      </dependency>
      <dependency>
        <groupId>org.apache.maven.resolver</groupId>
        <artifactId>maven-resolver-connector-basic</artifactId>
        <version>${resolverVersion}</version>
      </dependency>
      <dependency>
        <groupId>org.apache.maven.resolver</groupId>
        <artifactId>maven-resolver-transport-file</artifactId>
        <version>${resolverVersion}</version>

                }
            }
        """
    }

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

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

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

            throws ArtifactResolutionException, ArtifactNotFoundException {
        if (Artifact.LATEST_VERSION.equals(artifact.getVersion())) {
            try {
                String version = resolveVersion(artifact, request);
                if (Artifact.LATEST_VERSION.equals(version)) {
                    throw new ArtifactNotFoundException("Unable to determine the latest version", artifact);
                }

            throws ArtifactResolutionException, ArtifactNotFoundException {
        if (Artifact.RELEASE_VERSION.equals(artifact.getVersion())) {
            try {
                String version = resolveVersion(artifact, request);

                if (Artifact.RELEASE_VERSION.equals(version)) {
                    throw new ArtifactNotFoundException("Unable to determine the release version", artifact);
                }

        nonNull(request, "request");
        InternalSession session = InternalSession.from(request.getSession());

        try {
            VersionResult res = repositorySystem.resolveVersion(
                    session.getSession(),
                    new VersionRequest(
                            session.toArtifact(request.getArtifactCoordinate()),

                a = a.setVersion(versionResult.getVersion());

                versionRequest =
                        new VersionRequest(pomArtifact, request.getRepositories(), request.getRequestContext());
                versionRequest.setTrace(trace);
                versionResult = versionResolver.resolveVersion(session, versionRequest);