ConcurrentHashMap<VariantResolveMetadata.Identifier, ResolvedVariant> map = new ConcurrentHashMap<>();
        return new ResolvedVariantCache() {
            @Override
            public ResolvedVariant computeIfAbsent(VariantResolveMetadata.Identifier key, Function<? super VariantResolveMetadata.Identifier, ? extends ResolvedVariant> mappingFunction) {
                return map.computeIfAbsent(key, mappingFunction);

import java.util.Collection;
import java.util.List;

import static org.gradle.api.internal.artifacts.ivyservice.resolveengine.artifact.ResolvedArtifactSet.EMPTY;

public class ArtifactBackedResolvedVariant implements ResolvedVariant {
    private final VariantResolveMetadata.Identifier identifier;
    private final DisplayName displayName;
    private final AttributeContainerInternal attributes;
    private final ImmutableCapabilities capabilities;

import org.gradle.api.artifacts.component.ComponentIdentifier;
import org.gradle.api.artifacts.result.ResolvedVariantResult;
import org.gradle.api.internal.artifacts.ivyservice.resolveengine.artifact.ResolvedVariant;
import org.gradle.api.internal.artifacts.result.DefaultResolvedVariantResult;
import org.gradle.api.internal.attributes.AttributeDesugaring;
import org.gradle.api.internal.attributes.AttributesSchemaInternal;

        0 * visitor._

        when:
        set2.artifacts.visitDependencies(visitor)

        then:
        1 * visitor.add(artifact1)
        0 * visitor._
    }

    ResolvedVariant of(List<ResolvableArtifact> artifacts) {
        return new ArtifactBackedResolvedVariant(id, variantDisplayName, attributes, ImmutableCapabilities.EMPTY, [], { artifacts as Set })
    }

            with(resolver.resolveVariant(ModuleVersionIdentifier, project.identityPath, it)) {
                group == "pub-group-child1"
                name == "pub-name-child1"
                version == "pub-version-child1"
            }
        }
        ["child2_variant1", "child2_variant2"].each {
            with(resolver.resolveVariant(ModuleVersionIdentifier, project.identityPath, it)) {

        Set<ResolvedVariantResult> resolvedVariants = new HashSet<>(component.getVariants());
        encoder.writeSmallInt(allVariants.size());
        for (ResolvedVariantResult variant : allVariants) {
            resolvedVariantResultSerializer.write(encoder, variant);
            encoder.writeBoolean(resolvedVariants.contains(variant));
        }

     * project identified by {@code identityPath}.
     *
     * @return null if the {@code variantName} does not exist in the target project.
     */
    @Nullable
    <T> T resolveVariant(Class<T> coordsType, Path identityPath, String variantName);

        // Instead, the resolution result should expose the project coordinates via getExternalVariant.
        String variantName = variant.getDisplayName();
        ModuleVersionIdentifier coordinates = projectDependencyResolver.resolveVariant(ModuleVersionIdentifier.class, identityPath, variantName);

        if (coordinates == null) {
            throw new InvalidUserDataException(String.format(