- Variant javadoc provides com.google.code.gson:gson:2.8.5
               - Variant platform-compile provides com.google.code.gson:gson-derived-platform:2.8.5
               - Variant platform-runtime provides com.google.code.gson:gson-derived-platform:2.8.5
               - Variant runtime provides com.google.code.gson:gson:2.8.5
               - Variant sources provides com.google.code.gson:gson:2.8.5

        then:
        result == resolvedArtifactSet
        1 * attributeMatcher.matches(_, _, _) >> [variant]
        1 * variant.getArtifacts() >> resolvedArtifactSet
        0 * consumerProvidedVariantFinder._
    }

    def 'multiple match on variant results in ambiguous exception'() {
        given:
        def variantSet = variantSetOf([variant, otherVariant])

		pc := &meshconfig.ProxyConfig{}
		if err := protomarshal.ApplyYAML(v, pc); err == nil {
			if pc.GetImage().GetImageType() != "" {
				variant = pc.GetImage().GetImageType()
			}
		}
	}
	if variant == "default" {
		variant = ""
	}
	return variant
}

func NewEffectiveProxyConfigResolver(c analysis.Context) *EffectiveProxyConfigResolver {
	mc := &meshconfig.MeshConfig{}
	rootNamespace := ""

> Task :producer:outgoingVariants
--------------------------------------------------
Variant apiElements
--------------------------------------------------
API elements for the 'main' feature.

Attributes
    - org.gradle.category            = library
    - org.gradle.dependency.bundling = external
    - org.gradle.jvm.version         = 11
    - org.gradle.libraryelements     = jar
    - org.gradle.usage               = java-api

Artifacts

        module.getArtifact(classifier: classifier).expectGet()
    }

    def "prefers standard JVM variant in Java projects"() {
        given:
        prepareResolve('compileClasspath', 'jre')

        when:
        run ':checkDeps'

        then:
        expectStandardJVM()
    }

    def "Prefers Android variant in Android projects"() {
        given:
        prepareResolve('releaseCompileClasspath', 'android')

        ComponentGraphResolveState component,
        VariantGraphResolveState variant,
        DependencyGraphEdge dependency,
        GraphVariantSelector graphVariantSelector,
        AttributesSchemaInternal consumerSchema
    ) {
        this.variantResolver = variantResolver;
        this.component = component;
        this.variant = variant;
        this.componentId = component.getId();

                getVariants() >> [variant]
            }
        }
        consumerSchema = Mock(AttributesSchemaInternal)
    }

    def "returns empty set when component id does not match spec"() {
        when:
        def artifactSet = new VariantResolvingArtifactSet(variantResolver, component, variant, dependency, graphSelector, consumerSchema)

    def "can express preference for a certain variant with capabilities declared in published modules"() {
        given:
        repository {
            'org:testB:1.0' {
                variant('runtime') {
                    capability('org', 'testB', '1.0')
                }
                variant('runtimeAlt') {
                    capability('org', 'testB', '1.0')

        if (expected.length == 0) {
            assert parsedModuleMetadata.variant('apiElements').dependencies.empty
            assert parsedPom.scopes.compile == null
        } else {
            assert parsedModuleMetadata.variant('apiElements').dependencies*.coords as Set == expected as Set
            assert parsedModuleMetadata.variant('runtimeElements').dependencies*.coords.containsAll(expected)

import javax.annotation.Nullable;

/**
 * State for a component variant that is used to perform dependency graph resolution.
 *
 * <p>This does not include any information about the artifacts of the variant, which are generally not required during graph resolution.</p>
 */
public interface VariantGraphResolveState extends HasAttributes {
    /**