// encoded differently) and then every varint is a single byte long.
	components := make([]int, len(bytes)+1)

	// The first varint is 40*value1 + value2:
	// According to this packing, value1 can take the values 0, 1 and 2 only.
	// When value1 = 0 or value1 = 1, then value2 is <= 39. When value1 = 2,
	// then there are no restrictions on value2.
	var v int
	if !bytes.readBase128Int(&v) {
		return false
	}
	if v < 80 {

        def candidate2 = attributes(usage: 'java-runtime-extra', status: 'integration')
        def candidate3 = attributes(usage: 'java-api-extra', status: 'integration', bundling: value1)
        def candidate4 = attributes(usage: 'java-runtime-extra', status: 'integration', bundling: value2)
        def requested = attributes(usage: 'java-api')

        when:

			accessKey:          creds.AccessKey,
			secretKey:          creds.SecretKey,
			body:               []byte(`<LifecycleConfiguration><Rule><ID>id</ID><Filter><Prefix>logs/</Prefix><Tag><Key>Key1</Key><Value>Value1</Value></Tag></Filter><Status>Enabled</Status><Expiration><Days>365</Days></Expiration></Rule></LifecycleConfiguration>`),
			expectedRespStatus: http.StatusBadRequest,
			lifecycleResponse:  []byte(``),

					Name:      testPodName,
					Namespace: testNamespace,
					Annotations: map[string]string{
						"a1": "value1",
						"a2": "value2",
					},
					UID: testPodUID},
			},
			mode: 0644,
			payload: map[string]util.FileProjection{
				"annotation": {Data: []byte("value1"), Mode: 0644},
			},
			success: true,
		},
		{
			name: "annotation-error",

        }

        then:
        0 * listener.onChange(_, _)
    }

    def "replaceAll() uses reference equality for non-primitives"() {
        def value1 = [1]
        def value2 = [1]

        def map = getMapUnderTestToWrite(value: value1)
        when:
        map.replaceAll { k, v ->
            return value2
        }

        then:
        1 * listener.onChange("value", value2)
    }

    def "duplicate names in nested iterable are allowed"() {
        buildFile << taskWithNestedInput()
        buildFile << namedBeanClass()
        buildFile << """
            myTask.nested = [new NamedBean('name', 'value1'), new NamedBean('name', 'value2')]
        """

        expect:
        succeeds "myTask"
    }

    def "nested Provider is unpacked"() {
        buildFile << taskWithNestedInput()

  @CanIgnoreReturnValue
  public <T> ClassSanityTester setDistinctValues(Class<T> type, T value1, T value2) {
    checkNotNull(type);
    checkNotNull(value1);
    checkNotNull(value2);
    checkArgument(!Objects.equal(value1, value2), "Duplicate value provided.");
    distinctValues.replaceValues(type, ImmutableList.of(value1, value2));
    setDefault(type, value1);
    return this;
  }

  /**

        def visitor = Mock(ResolvedArtifactSet.Visitor)
        def artifactVisitor = Mock(ArtifactVisitor)
        def files = Mock(FileCollectionInternal)
        def attrs1 = attributesFactory.of(Attribute.of('attr', String), 'value1')
        def attrs2 = attributesFactory.of(Attribute.of('attr', String), 'value2')

        when:
        set.visit(visitor)

        then:
        _ * dep.componentId >> id
        _ * dep.files >> files

			if sample == nil {
				// Not a valid sample, exit.
				return b, locs, nil
			}

			// Java profiles have data/fields inverted compared to other
			// profile types.
			var err error
			value1, value2, value3 := sample[2], sample[1], sample[3]
			addrs, err := parseHexAddresses(value3)
			if err != nil {
				return nil, nil, fmt.Errorf("malformed sample: %s: %v", line, err)
			}

			var sloc []*Location

	<info organisation="myorg"
	       module="mymodule"
	       revision="myrev"
	       status="status"
           branch="branch"
	       publication="20041101110000"
	       e:attr1="value1">

		<license name="MyLicense" url="http://www.my.org/mymodule/mylicense.html"/>
		<ivyauthor name="jayasoft" url="http://www.jayasoft.org/"/>
		<ivyauthor name="myorg" url="http://www.myorg.org/"/>