/**
     * Defines a 'blue' variant for the given module.
     */
    def <T extends MavenModule> T withColorVariants(T module) {
        module.adhocVariants().variant('runtime', [color: 'blue']).withModuleMetadata()
        return module
    }

    /**
     * Each project produces 'blue' variants and has a `resolve` task that resolves the 'green' variant. The 'blue' variant will contain

        super(id, new ComponentAttributesAwareVariant(variant, attributesFactory, componentLevelAttributes), ((AbstractRealisedModuleComponentResolveMetadata.ImmutableRealisedVariantImpl)variant).getDependencyMetadata());
    }

    /**

            this.objectFactory = objectFactory;
        }

        @Override
        public ConfigurationVariant getConfigurationVariant() {
            return variant;
        }

        @Override
        public void skip() {
            skip = true;
        }

        @Override
        public void mapToOptional() {
            this.optional = true;
        }

        @Override

        }
    }

    static ScopeMapping scopeForVariant(SoftwareComponentVariant variant) {
        if (variant instanceof MavenPublishingAwareVariant) {
            return ((MavenPublishingAwareVariant) variant).getScopeMapping();
        }
        // TODO: Update native plugins to use maven-aware variants so we can remove this.
        String name = variant.getName();
        if ("api".equals(name) || "apiElements".equals(name)) {

            String getCompile() {
                return withProject("compile${buildType}${variant}${languageTaskSuffix}")
            }

            String getLink() {
                return withProject("link${buildType}${variant}")
            }

            String getCreate() {
                return withProject("create${buildType}${variant}")
            }

            String getInstall() {

    }

    @Override
    protected List<String> getTasksToAssembleDevelopmentBinary(String variant) {
        return [":compileDebug${variant.capitalize()}Cpp", ":compileTest${variant.capitalize()}Cpp", ":linkTest${variant.capitalize()}", ":installTest${variant.capitalize()}", ":runTest${variant.capitalize()}"]
    }

    @Override
    String getTestedComponentDsl() {
        return "library"
    }

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>

 *
 * <p>The configuration being resolved should declare the same dependencies as the variant
 * being published. Then, each outgoing edge of the analyzed resolution result will correspond
 * to each declared dependency on the published variant. We build a mapping from requested
 * coordinates to resolved coordinates. Then, when resolving individual variant coordinates,

The following statements must hold for the variants:

- Variant name must be unique per module
- Each variant must have at least one attribute
- Two variants cannot have the same attributes and capabilities
- If there is at least one dependency in any variant, at least one must carry version information

### `attributes` value

    }

    def "shows published variant details"() {
        given:
        mavenRepo.with {
            def leaf = module('org.test', 'leaf', '1.0')
                .withModuleMetadata()