}
		hv[i] = byte(x)
	}

	// Return hash and meta-data len
	return hv, base.Flag.Cfg.CoverageInfo.MetaLen
}

func registerMeta(cnames names, hashv [16]byte, mdlen int) {
	// Materialize expression for hash (an array literal)
	pos := cnames.InitFn.Pos()
	elist := make([]ir.Node, 0, 16)
	for i := 0; i < 16; i++ {
		elem := ir.NewInt(base.Pos, int64(hashv[i]))
		elist = append(elist, elem)
	}

        def hash1 = unfilteredHasher.hash(propertiesEntry1)
        def hash2 = unfilteredHasher.hash(propertiesEntry2)
        def hash3 = filteredHasher.hash(propertiesEntry1)
        def hash4 = filteredHasher.hash(propertiesEntry2)

        expect:
        hash1 != hash2
        hash2 != hash4
        hash3 != hash4
        hash1 != hash3

        where:

        def hash1 = unfilteredHasher.hash(manifestEntry1)
        def hash2 = unfilteredHasher.hash(manifestEntry2)
        def hash3 = hasher.hash(manifestEntry1)
        def hash4 = hasher.hash(manifestEntry2)

        then:
        hash1 != hash2
        hash3 != hash4

        and:
        hash1 == hash3
        hash2 == hash4

        when:

        then:
        hash2 == hash1
    }

    def 'hasher works without calling final hash method'() {
        given:
        def value = ('a'..'z').join()

        when:
        def hasher1 = Hashing.newHasher()
        hasher1.putString(value)
        def hash = hasher1.hash()

        and:
        def hasher2 = Hashing.newHasher()
        hasher2.putString(value)
        // no call to hasher2.hash()

// Package hash provides interfaces for hash functions.
package hash

import "io"

// Hash is the common interface implemented by all hash functions.
//
// Hash implementations in the standard library (e.g. [hash/crc32] and
// [crypto/sha256]) implement the [encoding.BinaryMarshaler] and
// [encoding.BinaryUnmarshaler] interfaces. Marshaling a hash implementation

// limitations under the License.

package hash

import (
	"encoding/hex"

	"github.com/cespare/xxhash/v2"
)

type Hash interface {
	Write(p []byte) (n int)
	WriteString(s string) (n int)
	Sum() string
	Sum64() uint64
}

type instance struct {
	hash *xxhash.Digest
}

var _ Hash = &instance{}

func New() Hash {
	return &instance{
		hash: xxhash.New(),
	}
}

        def jarfile2 = tmpDir.file("test2.jar")
        createJarWithAttributes(jarfile2, ["Implementation-Version": "1.0.1"])

        def hash1 = zipHasher.hash(snapshotContext(jarfile))
        def hash2 = zipHasher.hash(snapshotContext(jarfile2))

        expect:
        hash1 != hash2
    }

    def "manifest attributes are ignored"() {
        given:
        def jarfile = tmpDir.file("test.jar")

    }

    def "#a == #b: #equals"() {
        def hashA = HashCode.fromString(a)
        def hashB = HashCode.fromString(b)

        expect:
        (hashA == hashB) == equals
        (hashB == hashA) == equals

        where:
        a                                  | b                                  | equals

      }
    } else {
      assertEquals(expectedHashCode.asLong.longValue(), hash.asLong());
    }
    assertEquals(expectedHashCode.toString, hash.toString());
    assertSideEffectFree(hash);
    assertReadableBytes(hash);
  }

  private static void assertSideEffectFree(HashCode hash) {
    byte[] original = hash.asBytes();
    byte[] mutated = hash.asBytes();
    mutated[0]++;

	})
	return usersAndGroups, err
}

// DeepHashObject writes specified object to hash using the spew library
// which follows pointers and prints actual values of the nested objects
// ensuring the hash does not change when a pointer changes.
// Copied from k8s.io/kubernetes/pkg/util/hash/hash.go#DeepHashObject
func DeepHashObject(hasher hash.Hash, objectToWrite interface{}) {
	hasher.Reset()