// HasData is true if the event has trailer consisting of a
	// varint length followed by unencoded bytes of some data.
	//
	// An event may not be both a timed event and have data.
	HasData bool

	// IsStack indicates that the event represents a complete
	// stack trace. Specifically, it means that after the arguments
	// there's a varint length, followed by 4*length varints. Each
	// group of 4 represents the PC, file ID, func ID, and line number

	return len(buf.arr)-buf.pos >= size
}

// varintAt writes varint v at byte position pos in buf. This always
// consumes traceBytesPerNumber bytes. This is intended for when the caller
// needs to reserve space for a varint but can't populate it until later.
// Use varintReserve to reserve this space.
func (buf *traceBuf) varintAt(pos int, v uint64) {
	for i := 0; i < traceBytesPerNumber; i++ {

 */

package org.gradle.api.internal.artifacts;

import org.gradle.api.artifacts.component.ComponentIdentifier;

/**
 * A node identifier that uniquely identifies a variant within a component by the variant's name.
 *
 * Note: Generally, variants should be identified by their attributes and capabilities, as the name
 * is more of a human-readable identifier.
 */
public class ComponentVariantNodeIdentifier implements NodeIdentifier {

            Collections.emptyList()
        );

        // It is fine if no graph variants satisfy our request.
        // Variant reselection allows no target variants to be found.
        if (graphVariant == null) {
            return ImmutableSet.of();
        }

        // Next, return all artifact variants for the selected graph variant.
        return getArtifactsForGraphVariant(graphVariant);
    }

    /**

        if (variants == null || variants.isEmpty() || !allArtifactSet.isEmpty()) {
            visitor.visitOwnVariant(displayName, attributes.asImmutable(), allArtifactSet);
        }
        if (variants != null) {
            for (ConfigurationVariantInternal variant : variants.withType(ConfigurationVariantInternal.class)) {

        def variantDef = publications.variants.create("child")
        variantDef.attributes.attribute(Attribute.of("thing", String), "value")
        variantDef.artifacts.add(artifact)

        expect:
        def variants = getOutgoingVariants(publications)
        variants.size() == 1

        def child = variants.first()
        child.displayName.displayName == '<config> variant child'

        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:

import java.util.List;
import java.util.Set;

/**
 * Immutable metadata for a component variant instance that is used to perform dependency graph resolution.
 *
 * <p>Note that this metadata does not provide any information about the available artifacts of this variants, as this may be expensive to resolve.
 * Information about the artifacts can be accessed via the methods of {@link ComponentGraphResolveState}.</p>

        The only attribute distinguishing these variants is 'org.gradle.native.architecture'. Add this attribute to the consumer's configuration to resolve the ambiguity:
          - Value: 'x86-64' selects variant: 'natives-windows-runtime'

    def "expressing a preference for a variant with capabilities declared in a published modules does not evict unrelated variants"() {
        given:
        repository {
            'org:testB:1.0' {
                variant('runtime') {
                    capability('org', 'testB', '1.0')
                }
                variant('runtimeAlt') {
                    capability('org', 'testB', '1.0')