*/
@Beta
@ElementTypesAreNonnullByDefault
public interface Hasher extends PrimitiveSink {
  @CanIgnoreReturnValue
  @Override
  Hasher putByte(byte b);

  @CanIgnoreReturnValue
  @Override
  Hasher putBytes(byte[] bytes);

  @CanIgnoreReturnValue
  @Override
  Hasher putBytes(byte[] bytes, int off, int len);

  @CanIgnoreReturnValue
  @Override
  Hasher putBytes(ByteBuffer bytes);

  @CanIgnoreReturnValue

 */
@Beta
@ElementTypesAreNonnullByDefault
public interface Hasher extends PrimitiveSink {
  @CanIgnoreReturnValue
  @Override
  Hasher putByte(byte b);

  @CanIgnoreReturnValue
  @Override
  Hasher putBytes(byte[] bytes);

  @CanIgnoreReturnValue
  @Override
  Hasher putBytes(byte[] bytes, int off, int len);

  @CanIgnoreReturnValue
  @Override
  Hasher putBytes(ByteBuffer bytes);

  @CanIgnoreReturnValue

// 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

	"sort"
	"strings"
)

// DefaultHash is the default hash function used in new go.sum entries.
var DefaultHash Hash = Hash1

// A Hash is a directory hash function.
// It accepts a list of files along with a function that opens the content of each file.
// It opens, reads, hashes, and closes each file and returns the overall directory hash.
type Hash func(files []string, open func(string) (io.ReadCloser, error)) (string, error)

     */
    void put(Hashable hashable);

    /**
     * Feed a {@code null} value into the hasher.
     */
    void putNull();

    /**
     * Returns the combined hash.
     *
     * If the build cache hash is invalid, an exception is thrown.
     *
     * @throws IllegalStateException if the hasher state is invalid.
     */
    HashCode hash();

        expect:
        hasher.getClassLoaderHash(runtimeLoader) == hashFor("system")
    }

    def "hashes unknown classloader"() {
        def unknownLoader = Mock(ClassLoader)
        expect:
        hasher.getClassLoaderHash(unknownLoader) == null
    }

    def "hashes hashed classloader"() {
        def hashedLoader = new DelegatingLoader(runtimeLoader)
        def hashedLoaderHash = TestHashCodes.hashCodeFrom(123456)

			if hash1a != hash1 {
				t.Errorf("repeated hash of the same object (%q) produced different results: %d vs %d", toString(tc()), hash1, hash1a)
			}
			if hash2a != hash2 {
				t.Errorf("repeated hash of the same object (%q) produced different results: %d vs %d", toString(tc()), hash2, hash2a)
			}
			if hash1a != hash2a {
				t.Errorf("hash of the same object produced (%q) different results: %d vs %d", toString(tc()), hash1a, hash2a)
			}
		}

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

            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;
            }

        }*.join().toSet()

        then:
        hashes.size() == threadRange.size()
    }

    def 'null does not collide with other values'() {
        expect:
        def hasher = Hashing.newHasher()
        hasher.putNull()
        def hash = hasher.hash()
        hash != Hashing.hashString("abc")
    }

    def 'hash collision for bytes'() {
        def left = [[1, 2, 3], [4, 5]]
        def right = [[1, 2], [3, 4, 5]]