mainMetadata.variants.size() == 5
        def api = mainMetadata.variant("api")
        api.dependencies.empty
        api.files.size() == 1
        api.files[0].name == 'cpp-api-headers.zip'
        api.files[0].url == 'test-1.2-cpp-api-headers.zip'
        mainMetadata.variant("debugLink").availableAt.coords == "some.group:test_debug:1.2"

        this.selectedByVariantAwareResolution = selectedByVariantAwareResolution;
    }

    public List<? extends VariantGraphResolveState> getVariants() {
        return variants;
    }

    public boolean isSelectedByVariantAwareResolution() {
        return selectedByVariantAwareResolution;
    }

        // Verify Gradle metadata particulars
        assert backingModule.parsedModuleMetadata.variants*.name as Set == ['apiElements', 'runtimeElements'] as Set
        assert backingModule.parsedModuleMetadata.variant('apiElements').files*.name == [backingModule.jarFile.name]
        assert backingModule.parsedModuleMetadata.variant('runtimeElements').files*.name == [backingModule.jarFile.name]
    }

    void assertNotPublished() {

        if (variants.isEmpty()) {
            return maybeDeriveVariants();
        }
        ImmutableList.Builder<ModuleConfigurationMetadata> configurations = new ImmutableList.Builder<>();
        for (ComponentVariant variant : variants) {
            configurations.add(new RealisedVariantBackedConfigurationMetadata(getId(), variant, getAttributes(), getAttributesFactory()));
        }

        switch (failureSubType) {
            case NO_VARIANTS_EXIST:
                formatter.node("No variants exist.");
                break;
            case NO_VARIANTS_HAVE_ATTRIBUTES:
                formatter.node("None of the variants have attributes.");
                break;
            case NO_VARIANT_MATCHES_REQUESTED_ATTRIBUTES:
                // We're sorting the names of the configurations and later attributes

}

// DeleteTaintsByKey removes all the taints that have the same key to given taintKey
func DeleteTaintsByKey(taints []v1.Taint, taintKey string) ([]v1.Taint, bool) {
	newTaints := []v1.Taint{}
	deleted := false
	for i := range taints {
		if taintKey == taints[i].Key {
			deleted = true
			continue
		}
		newTaints = append(newTaints, taints[i])
	}
	return newTaints, deleted
}

        def gradleLibrary = mavenHttpRepo.module("org", "lib", "1.0")
                .adhocVariants()
                .variant("apiElements", ['org.gradle.usage': Usage.JAVA_API, 'groovy.runtime': 'classic'])
                .variant("runtimeElements", ['org.gradle.usage': Usage.JAVA_RUNTIME, 'groovy.runtime': 'classic'])
                .variant("apiElementsIndy", ['org.gradle.usage': Usage.JAVA_API, 'groovy.runtime': 'indy']) {

            String variantName = GUtil.toWords(variant.getKey());
            builder.item(variantName, RendererUtils.displayValueOf(variant.getValue()));
        }
    }

    protected void renderDetails(T binary, TextReportBuilder builder) {
    }

    protected void renderTasks(T binary, TextReportBuilder builder) {
    }

        artifactSet.select(new ArtifactVariantSelector() {
            @Override
            ResolvedArtifactSet select(ResolvedVariantSet candidates, ImmutableAttributes requestAttributes, boolean allowNoMatchingVariants, ArtifactVariantSelector.ResolvedArtifactTransformer factory) {
                assert candidates.variants.size() == 2

    suspend fun WriteContext.writeVariants(variants: Set<VariantResolveMetadata>) {
        writeCollection(variants) {
            writeVariant(it)
        }
    }

    private
    suspend fun WriteContext.writeVariant(variant: VariantResolveMetadata) {
        writeString(variant.name)
        write(variant.identifier)
        write(variant.attributes)
        writeCollection(variant.artifacts)
    }