hasher = new CachingFileHasher(target, cacheAccess, new StringInterner(), timeStampInspector, "fileHashes", fileSystem, 1000, statisticsCollector)
    }

    def "hashes file when hash not cached"() {
        def stat = fileSystem.stat(file)

        when:
        def result = hasher.hash(file)

        then:
        result == hash

        and:

// and SHAKE hash functions, as well as utility functions for hashing
// bytes.

import (
	"hash"
)

// New224 creates a new SHA3-224 hash.
// Its generic security strength is 224 bits against preimage attacks,
// and 112 bits against collision attacks.
func New224() hash.Hash {
	return new224()
}

// New256 creates a new SHA3-256 hash.

limitations under the License.
*/

package hash

import (
	"fmt"
	"hash"

	"k8s.io/apimachinery/pkg/util/dump"
)

// 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.
func DeepHashObject(hasher hash.Hash, objectToWrite interface{}) {
	hasher.Reset()

	"encoding/hex"

	"github.com/minio/minio/internal/hash/sha256"
)

// getSHA256Hash returns SHA-256 hash in hex encoding of given data.
func getSHA256Hash(data []byte) string {
	return hex.EncodeToString(getSHA256Sum(data))
}

// getSHA256Hash returns SHA-256 sum of given data.
func getSHA256Sum(data []byte) []byte {
	hash := sha256.New()
	hash.Write(data)
	return hash.Sum(nil)
}

            if (knownId != null) {
                hasher.putBytes(knownId);
                return false;
            }
            if (cl instanceof CachingClassLoader || cl instanceof MultiParentClassLoader) {
                return true;
            }
            HashCode hash = classLoaderFactory.getClassLoaderClasspathHash(cl);
            if (hash != null) {
                hasher.putHash(hash);
                return true;
            }

        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()

        hasher.putInt(array.length);
        for (char c : array) {
            hasher.putInt(c);
        }
    }

    public static void putDoubles(Hasher hasher, double[] array) {
        hasher.putInt(array.length);
        for (double d : array) {
            hasher.putDouble(d);
        }
    }

    public static void putFloats(Hasher hasher, float[] array) {
        hasher.putInt(array.length);

	}

	return mix(m5^s, mix(a^hashkey[1], b^seed))
}

func memhash32Fallback(p unsafe.Pointer, seed uintptr) uintptr {
	a := r4(p)
	return mix(m5^4, mix(a^hashkey[1], a^seed^hashkey[0]))
}

func memhash64Fallback(p unsafe.Pointer, seed uintptr) uintptr {
	a := r8(p)
	return mix(m5^8, mix(a^hashkey[1], a^seed^hashkey[0]))
}

func mix(a, b uintptr) uintptr {
	hi, lo := math.Mul64(uint64(a), uint64(b))

        hasher.putBytes(bytes, off, len);
        out.write(bytes, off, len);
    }

    public HashCode hash() {
        return hasher.hash();
    }

    @Override
    public void close() throws IOException {
        out.close();
    }

import org.gradle.internal.fingerprint.hashing.ZipEntryContext;
import org.gradle.internal.hash.HashCode;
import org.gradle.internal.hash.Hasher;
import org.gradle.internal.hash.Hashing;

import javax.annotation.Nullable;
import java.io.IOException;

/**
 * Hashes contents of resources files and {@link ZipEntry}s) in runtime classpath entries.
 *