println "\$id -> \${it.displayName}"
                              if (it.displayName != 'default') {
                                  throw new AssertionError("Unexpected resolved variant \$it")
                              }
                          }
                      }
                  }
               }
            }
        """
        file("lib/build.gradle") << """

     *
     * @return the resolved variants for this component
     *
     * @since 5.2
     */
    List<ResolvedVariantResult> getVariants();

    /**
     * Returns the dependencies of a specific variant. It is possible for a component to be selected multiple
     * times with different variants (for example, the main component and its test fixtures). The dependencies

        and: "some variants in the component, or none"
        (0..<ownVariants).forEach {
            metadata.addVariant("variant$it", ImmutableAttributes.EMPTY)
        }

        and: "a rule that adds a variant to all components"
        metadataRuleContainer.addClassRule(
            new SpecConfigurableRule(

            version.text() == "1.0"
            type.text() == "pom"
            scope.text() == "import"
        }

        ["apiElements", "runtimeElements"].each {
            repoModule.parsedModuleMetadata.variant(it) {
                dependency("org:foo:1.0") {
                    exists()
                    isLast()
                }
            }
        }
    }

    public void execute(ComponentMetadataContext context) {
            println "Rule executed on \${context.details.id}"
            context.details.allVariants {
                println("Variant \$it")
                withDependencies { deps ->
                    deps.each {
                       println "See dependency: \$it"
                    }
                }
            }
    }
}

    /**
     * In general, default extends all configurations such that you get 'everything' when depending on default.
     * If a variant is optional, however it is not included.
     * If a variant represents the Java API variant, it is also not included, because the Java Runtime variant already includes everything
     * (including both also works but would lead to some duplication, that might break backwards compatibility in certain cases).
     */

        }
        assert values.formatVersion == '1.1'
        assert values.createdBy.gradle.version == GradleVersion.current().version
        variants = (values.variants ?: []).collect { new Variant(it.name, it) }
    }

    @Nullable
    CreatedBy getCreatedBy() {
        def createdBy = values.createdBy
        if (createdBy == null) {
            return null
        }

If you choose the capability name yourself or add more capabilities to a variant, it is recommended to follow the same convention.
--

[[sec::publishing_feature_variants]]
== Publishing features

--
Depending on the metadata file format, publishing features may be lossy:

This is typical of libraries published to external repositories.
In this case, we know that even if we don't have an exact match (API), we can still compile against the runtime variant (it contains _more_ than what we need to compile but it's still ok to use).

====

The rule creates an `apiElements` variant based on the `compile` configuration and a `runtimeElements` variant based on the `default` configuration of each ivy module.
For each variant, it sets the corresponding <<#sec:variant-aware-matching,Java ecosystem attributes>>.
Dependencies and artifacts of the variants are taken from the underlying configurations.