return conf;
    }

    /**
     * Ensures the target variant matches the request attributes and is consumable. This needs to be called
     * for variants that are selected by means other than attribute matching.
     *
     * Note: This does not need to be called for variants selected via attribute matching, since
     * attribute matching ensures selected variants are compatible with the requested attributes.
     */

            .stream()
            .flatMap(variant -> variant.prepareForArtifactResolution().getArtifactVariants().stream())
            .map(variant -> new DefaultResolvedVariantResult(
                component.getId(),
                Describables.of(variant.getName()),
                component.getAttributeDesugaring().desugar(variant.getAttributes().asImmutable()),

        }
        variants.get(outgoingConfiguration).addAction(action);
    }

    @Override
    public Set<? extends UsageContext> getUsages() {
        if (cachedVariants == null) {
            ImmutableSet.Builder<UsageContext> builder = new ImmutableSet.Builder<>();

swift-library-variant-task-graph.png...

cpp-library-variant-task-graph.png...

        List<TestVariant> variants = new ArrayList<TestVariant>();
        variants.add(TestVariant.tapiCurrent(rootId, discoveryRequest));
        variants.add(TestVariant.selected(rootId, discoveryRequest));
        variants.add(TestVariant.tapiTargetLoaded(rootId, discoveryRequest));

        return variants;
    }

  - Configuration ':a:default' variant v1:
      - Unmatched attribute:
          - Doesn't say anything about usage (required 'compile')
  - Configuration ':a:default' variant v2:
      - Unmatched attribute:
          - Doesn't say anything about usage (required 'compile')""")
    }

  compileTestVariantCpp -> linkTestVariant -> installTestVariant -> runTestVariant [dir=back, style=dashed]
  compileTestVariantCpp[label=<compile<i>Variant</i>Cpp>]
  linkTestVariant[label=<link<i>Variant</i>>]
  installTestVariant[label=<installTest<i>Variant</i>>]
  runTestVariant[label=<runTest<i>Variant</i>>]

        then: "the result should have the variant added by the rule"
        def variantsForGraphTraversal = result.variantsForGraphTraversal
        variantsForGraphTraversal.size() == ownVariants + 1
        def variant = variantsForGraphTraversal.find { it.name == "test" }
        variant != null
        "org.gradle.test" in variant.attributes.keySet().collect { it.name }

        where:

    @Override
    public Set<? extends SoftwareComponent> getVariants() {
        return variants;
    }

    public void addArtifact(PublishArtifact artifact) {
        artifacts.add(artifact);
    }

    /**
     * Adds a child variant
     */
    public void addVariant(SoftwareComponent variant) {
        variants.add(variant);
    }