pkg hash/maphash, method (ComparableHasher[$0]) Equal($0, $0) bool #70471
pkg hash/maphash, method (ComparableHasher[$0]) Hash(*Hash, $0) #70471
pkg hash/maphash, type ComparableHasher[$0 comparable] struct #70471
pkg hash/maphash, type Hasher[$0 interface{}] interface { Equal, Hash } #70471
pkg hash/maphash, type Hasher[$0 interface{}] interface, Equal($0, $0) bool #70471

    d3 = Depends(dep, scope="function")
    d4 = Depends(dep, scope="function")

    s1 = Security(dep)
    s2 = Security(dep)

    assert hash(d1) == hash(d2)
    assert hash(s1) == hash(s2)
    assert hash(d1) != hash(d3)

	"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)
}

type UUIDHash struct {
	uuid []byte
}

// Write -  implement hash.Hash Write
func (u UUIDHash) Write(p []byte) (n int, err error) {
	return len(p), nil
}

// Sum -  implement md5.Sum
func (u UUIDHash) Sum(b []byte) []byte {
	return u.uuid
}

// Reset -  implement hash.Hash Reset
func (u UUIDHash) Reset() {}

// Size -  implement hash.Hash Size
func (u UUIDHash) Size() int {
	return len(u.uuid)
}

pkg hash, type XOF interface { BlockSize, Read, Reset, Write } #69518
pkg hash, type XOF interface, BlockSize() int #69518
pkg hash, type XOF interface, Read([]uint8) (int, error) #69518
pkg hash, type XOF interface, Reset() #69518
pkg hash, type XOF interface, Write([]uint8) (int, error) #69518
pkg hash/maphash, method (*Hash) Clone() (hash.Cloner, error) #69521
pkg io/fs, func Lstat(FS, string) (FileInfo, error) #49580

  static class Element implements Comparable<Element> {
    final int hash;

    Element(int hash) {
      this.hash = hash;
    }

    @Override
    public boolean equals(@Nullable Object obj) {
      return this == obj || (obj instanceof Element && ((Element) obj).hash == hash);
    }

    @Override
    public int hashCode() {
      return hash;
    }

    @Override

		}
		var (
			hash = algorithm.New()
			msg  = make([]byte, 0, hash.Size()*hash.BlockSize())
			sum  = make([]byte, 0, hash.Size())
		)
		for i := 0; i < hash.Size()*hash.BlockSize(); i += hash.Size() {
			hash.Write(msg)
			sum = hash.Sum(sum[:0])
			msg = append(msg, sum...)
			hash.Reset()
		}
		if !bytes.Equal(sum, checksum) {

 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package com.google.common.hash;

import static com.google.common.hash.Funnels.byteArrayFunnel;
import static com.google.common.hash.Hashing.murmur3_32;
import static com.google.common.hash.Hashing.murmur3_32_fixed;
import static java.nio.charset.StandardCharsets.UTF_16;
import static java.nio.charset.StandardCharsets.UTF_16LE;

/**
 * Benchmarks for comparing {@link MessageDigest}s and {@link com.google.common.hash.HashFunction}s
 * that wrap {@link MessageDigest}s.
 *
 * <p>Parameters for the benchmark are:
 *
 * <ul>
 *   <li>size: The length of the byte array to hash.
 *   <li>algorithm: the algorithm to hash with (e.g. MD5, SHA1, etc.).
 *   <li>hashMethod: how to hash the data (using the Hashing API or the MessageDigest API).
 * </ul>
 *

    @DisplayName("Should calculate MD4 hash correctly")
    void testMD4Hash() {
        // Given
        String input = "Hello World";
        byte[] data = input.getBytes();

        // When
        MessageDigest md4 = Crypto.getMD4();
        byte[] hash = md4.digest(data);

        // Then
        assertNotNull(hash);
        assertEquals(16, hash.length); // MD4 produces 128-bit hash
    }

    @Test