{0x81, 0x01},
		{0x7f},
		{0x03},
		{0x01},
		{0x00},
		{0x02},
		{0x04},
		{0x7e},
		{0x80, 0x01},
	}
	for _, b := range inputs {
		x, n := binary.Varint(b)
		if n != len(b) {
			fmt.Println("Varint did not consume all of in")
		}
		fmt.Println(x)
	}
	// Output:
	// -65
	// -64
	// -2
	// -1
	// 0
	// 1
	// 2
	// 63
	// 64

                if (visited.add([result, variant])) {
                    if (variant == null) {
                        println(root)
                    }
                    def dependencies = variant == null ? result.dependencies : result.getDependenciesForVariant(variant)
                    depth++
                    dependencies.each {

	return makeTag(tt), err
}

// Compose creates a Tag from individual parts, which may be of type Tag, Base,
// Script, Region, Variant, []Variant, Extension, []Extension or error. If a
// Base, Script or Region or slice of type Variant or Extension is passed more
// than once, the latter will overwrite the former. Variants and Extensions are
// accumulated, but if two extensions of the same type are passed, the latter

 * where different "variants" are actually represented as different artifacts, with
 * specific (type, extension, classifier) sub-coordinates, in addition to the GAV
 * (group, artifact, version) coordinates.
 *
 * It is preferable to use component metadata rules to properly describe the variants
 * of a module, so this variant selector should only be used when defining such rules

    // of its features. It should lazily react to the variants of the feature being added and configure
    // itself to in turn advertise those variants. However, this requires a more complete variant API,
    // which is still being designed. For now, we'll add the variants manually.

    @Override
    public void withJavadocJar() {
        JvmFeatureInternal feature = getMainFeature();

 * Used to select the artifacts given a particular variant selected during graph resolution.
 */
public interface ResolvedVariantSet {
    Describable asDescribable();

    AttributesSchemaInternal getSchema();

    /**
     * The variants available for artifact selection when variant reselection is not enabled.
     */
    Set<ResolvedVariant> getVariants();

    /**

        when:
        resolver.resolveVariant(ModuleVersionIdentifier, project.identityPath, "variant-name")

        then:
        def e = thrown(InvalidUserDataException)
        e.message == "Multiple child components may not share the same coordinates: pub-group:pub-name:pub-version"
    }

    def "detects variants with the same name"() {
        def child1 = Stub(TestComponent) {
            getUsages() >> [

.Setting Swift compiler options for all variants
====
include::sample[dir="snippets/swift/basic/kotlin",files="build.gradle.kts[tags=swift-compiler-options-all-variants]"]
include::sample[dir="snippets/swift/basic/groovy",files="build.gradle[tags=swift-compiler-options-all-variants]"]
====

    @Override
    String getTestConfiguration() { variantToTest }

    /**
     * Does the published metadata provide variants with attributes? Eventually all metadata should do that.
     * For Ivy and Maven POM metadata, the variants and attributes should be derived from configurations and scopes.
     */
    boolean getPublishedModulesHaveAttributes() { gradleMetadataPublished }

        selectedVariants.put(id, variant);
    }

    @Override
    public void visitComponentVariants(List<ResolvedVariantResult> allVariants) {
        this.allVariants = ImmutableList.copyOf(allVariants);
    }

    @Override
    public void endVisitComponent() {