import java.util.List;
import java.util.Set;

/**
 * Immutable metadata for a component variant instance that is used to perform dependency graph resolution.
 *
 * <p>Note that this metadata does not provide any information about the available artifacts of this variants, as this may be expensive to resolve.
 * Information about the artifacts can be accessed via the methods of {@link ComponentGraphResolveState}.</p>

        artifact2.classifier >> ""
        artifact2.extension >> "jar"
        def variant1 = createVariant([artifact1], [], 'api')
        def variant2 = createVariant([artifact2], [], 'runtime')
        def component = Stub(SoftwareComponentInternal)
        component.usages >> [variant1, variant2]
        def mavenArtifact = Mock(MavenArtifact)
        mavenArtifact.file >> artifactFile

    /**
     * Add a rule for adjusting an existing variant of the component.
     *
     * @param name name of the variant to adjust (e.g. 'compile')
     * @param action the action to modify the variant
     *
     * @since 4.4
     */
    void withVariant(String name, Action<? super VariantMetadata> action);

    /**
     * Add a rule for adjusting all variants of a component.
     *

                def root = result.root
                assert root.id.projectName == 'root'
                assert root.variants.size() == 2
                def conf = root.variants.find { it.displayName == 'conf' }
                def other = root.variants.find { it.displayName == 'other' }
                assert conf != null
                assert other != null
            }
        """

cpp-application-variant-task-graph.png...

        }
        with(javaLibrary.parsedModuleMetadata) {
            assert variants.size() == 1
            assert variants[0].name == "apiElements"
            assert variants[0].dependencies*.coords == ["org:foo:1.0"]
        }
    }

    def "can ignore all publication warnings by variant name"() {
        given:
        def silenceMethod = "suppressPomMetadataWarningsFor"

        if (variantMetadataRules.getAdditionalVariants().isEmpty()) {
            return variants;
        }
        Map<String, VariantGraphResolveMetadata> variantsByName;
        ImmutableList.Builder<VariantGraphResolveMetadata> builder = new ImmutableList.Builder<>();
        if (variants.isPresent()) {

- `buildId`: The buildId for the Gradle instance. A string

### `variants` value

This value must contain an array with zero or more elements. Each element must be an object with the following values:

- `name`: The name of the variant. A string. The name must be unique across all variants of the component.
- `attributes`: optional. When missing the variant is assumed to have no attributes.

====

What we have done here is that we have added a _new_ variant, which can be used _at runtime_, but contains instrumented classes instead of the normal classes.
However, it now means that for runtime, the consumer has to choose between two variants:

- `runtimeElements`, the regular variant offered by the `java-library` plugin
- `instrumentedJars`, the variant we have created

The only attribute distinguishing these variants is 'extra'. Add this attribute to the consumer's configuration to resolve the ambiguity:
  - Value: 'extra 2' selects variant: 'bar'
  - Value: 'extra' selects variant: 'foo'"""
    }

    /**