strings.HasSuffix(name, ".opendefer"),
			strings.HasSuffix(name, ".arginfo0"),
			strings.HasSuffix(name, ".arginfo1"),
			strings.HasSuffix(name, ".argliveinfo"):
			// These are just bytes, or varints.
			align = 1
		case strings.HasPrefix(name, "gclocals·"):
			// It has 32-bit fields.
			align = 4
		default:
			switch {
			case w.ctxt.Arch.PtrSize == 8 && s.Size%8 == 0:
				align = 8

// sequences and encoding and decoding of varints.
//
// Numbers are translated by reading and writing fixed-size values.
// A fixed-size value is either a fixed-size arithmetic
// type (bool, int8, uint8, int16, float32, complex64, ...)
// or an array or struct containing only fixed-size values.
//
// The varint functions encode and decode single integer values using

        1 * variant1.addFile("api.zip", "api.zop")
        1 * variant1.addFile("api-2.zip", "api-2.zop")
        1 * variant1.setAvailableExternally(false)
        1 * metadata.addVariant("runtime", attributes(usage: "runtime", packaging: "zip")) >> variant2
        1 * variant2.addFile("api.zip", "api.zop")
        1 * variant2.addFile("runtime.zip", "runtime.zop")

        def variants = [variant1, variant2] as Set
        def transformedVariants = variants.collect { transformedVariant(it, requested)}

        given:
        set.schema >> producerSchema
        set.variants >> variants
        set.asDescribable() >> Describables.of('<component>')
        variant1.attributes >> typeAttributes("jar")
        variant1.asDescribable() >> Describables.of('<variant1>')

        repository {
            id('org.test:moduleB:1.0') {
                variant('customVariant1') {
                    attribute 'format', 'custom'
                    artifact 'variant1'
                }
                variant('customVariant2') {
                    attribute 'format', 'custom'
                    artifact 'variant2'
                }
            }
        }

        when:

Sometimes we want to add _more variants_ to or modify _existing variants_ of an existing component.
For example, if you <<cross_project_publications.adoc#targeting-different-platforms, added a variant of a Java library for a different platform>>, you may just want to declare this additional variant on the `java` component itself.
In general, declaring additional variants is often the best solution to publish _additional artifacts_.

        toComponent.getCandidatesForGraphVariantSelection().variants.addAll(toConfig)

        expect:
        dep.selectVariants(variantSelector, attributes([:]), toComponent, attributesSchema, [] as Set).variants == [toConfig]
    }

    @Unroll("selects variant '#expected' from target component (#scenario)")
    def "selects the variant from target component that matches the attributes"() {

		return cr
	}
	return r
}

// Variant represents a registered variant of a language as defined by BCP 47.
type Variant struct {
	ID  uint8
	str string
}

// ParseVariant parses and returns a Variant. An error is returned if s is not
// a valid variant.
func ParseVariant(s string) (v Variant, err error) {
	defer func() {
		if recover() != nil {
			v = Variant{}
			err = ErrSyntax
		}
	}()

        def variant = Stub(VariantGraphResolveState)
        variant.toString() >> name
        variant.name >> name
        def configuration = Stub(ConfigurationGraphResolveState)
        component.getConfiguration(name) >> configuration
        configuration.name >> name
        configuration.toString() >> name
        configuration.asVariant() >> variant
        configuration.metadata >> metadata

	flag.Parse()

	var variants []Variant
	if *genExp {
		variants = expVariants
	} else if *genGeneric {
		variants = genericVariants
	} else {
		variants = traditionalVariants
	}
	for i := range variants {
		generate(&variants[i])
	}
}

// generate generates the code for variant `v` into a file named by `v.Path`.
func generate(v *Variant) {