function.bits(),
            function);
      }
    }

    @Override
    HashCode makeHash(Hasher[] hashers) {
      byte[] bytes = new byte[bits() / 8];
      int i = 0;
      for (Hasher hasher : hashers) {
        HashCode newHash = hasher.hash();
        i += newHash.writeBytesTo(bytes, i, newHash.bits() / 8);
      }
      return HashCode.fromBytesNoCopy(bytes);
    }

	"istio.io/istio/pkg/cache"
	"istio.io/istio/pkg/test/util/assert"
)

func TestSmtEmptyTrie(t *testing.T) {
	smt := newSMT(hasher, nil, time.Minute)
	if !bytes.Equal([]byte{}, smt.root) {
		t.Fatal("empty trie root hash not correct")
	}
}

func TestSmtUpdateAndGet(t *testing.T) {
	smt := newSMT(hasher, nil, time.Minute)
	smt.atomicUpdate = false

	// Add data to empty trie
	keys := getFreshData(10)

 */

package org.gradle.internal.hash;

/**
 * A snapshot of the state of some thing.
 */
public interface Hashable {
    /**
     * Appends the snapshot to the given hasher.
     */
    void appendToHasher(Hasher hasher);

 */

package org.gradle.internal.fingerprint.hashing;

import org.gradle.internal.hash.Hasher;

/**
 * A resource normalizer which is configurable.
 *
 * Allows tracking changes to its configuration.
 */
public interface ConfigurableNormalizer {
    void appendConfigurationToHasher(Hasher hasher);

        try {
            PrimitiveHasher hasher = Hashing.newPrimitiveHasher();
            hasher.putHash(SIGNATURE);
            while (true) {
                int nread = inputStream.read(buffer);
                if (nread < 0) {
                    break;
                }
                outputStream.write(buffer, 0, nread);
                hasher.putBytes(buffer, 0, nread);
            }

import org.gradle.internal.classpath.ClasspathEntryVisitor;
import org.gradle.internal.hash.Hasher;
import org.objectweb.asm.ClassVisitor;

import java.io.IOException;

/**
 * Transform that modifies a class
 */
public interface ClassTransform {
    void applyConfigurationTo(Hasher hasher);

    }

    private
    fun Hasher.putBuildScan() {
        putByte(
            startParameter.run {
                when {
                    isNoBuildScan -> 0
                    isBuildScan -> 1
                    else -> 3
                }
            }
        )
    }

    private
    fun Hasher.appendRequestedTasks() {

        hash(actionLambdaSnapshot) != hash(consumerLambdaSnapshot)
    }

    private HashCode hash(Hashable hashable) {
        def hasher = Hashing.newHasher()
        hasher.put(hashable)
        return hasher.hash()
    }

    private ImplementationSnapshot createLambdaSnapshot(lambda) {
        ImplementationSnapshot.of(lambda.getClass().name, lambda, SHARED_CLASSLOADER_HASH)
    }

            return -1;
        }
        return normalizedContentHash.compareTo(o.getNormalizedContentHash());
    }

    @Override
    public void appendToHasher(Hasher hasher) {
        hasher.putHash(normalizedContentHash);
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) {
            return true;
        }

	lastHash, err := l.Put("foo", "bar")
	assert.NoError(t, err)
	assert.Equal(t, firstHash, lastHash)
}

func MyHasher(data ...[]byte) (result []byte) {
	hasher := murmur3.New64()
	for i := 0; i < len(data); i++ {
		hasher.Write(data[i])
	}
	result = hasher.Sum(nil)
	hasher.Reset()
	return
}

func TestCollision(t *testing.T) {
	hit := false
	HashCollider := func(data ...[]byte) []byte {
		if hit {