return newHasher().putObject(instance, funnel).hash();
  }

  @Override
  public HashCode hashUnencodedChars(CharSequence input) {
    int len = input.length();
    return newHasher(len * 2).putUnencodedChars(input).hash();
  }

  @Override
  public HashCode hashString(CharSequence input, Charset charset) {
    return newHasher().putString(input, charset).hash();
  }

  @Override

      key[i] = (byte) i;
      int seed = 256 - i;
      byte[] hash = hashFunction.hash(Arrays.copyOf(key, i), seed);
      System.arraycopy(hash, 0, hashes, i * hashBytes, hash.length);
    }

    // Then hash the result array
    byte[] result = hashFunction.hash(hashes, 0);

    // interpreted in little-endian order.
    int verification = Integer.reverseBytes(Ints.fromByteArray(result));

    if (expected != verification) {

        return nTOWFv2(domain, username, getNTHash(password));
    }

    /**
     * Generates the NTOWFv2 hash for the given domain, username, and password hash.
     *
     * @param domain the authentication domain
     * @param username the username
     * @param passwordHash
     *            NT password hash
     *
     * @return the calculated mac
     */

    /**
     * Decodes a similar document hash from its compressed and encoded form.
     * Reverses the encoding process applied by encodeSimilarDocHash.
     *
     * @param hash the encoded hash string to decode
     * @return the decoded hash string, or the original hash if decoding fails
     */
    public String decodeSimilarDocHash(final String hash) {

          new Sink(4).putUnencodedChars(s).hash(),
          new Sink(4).putBytes(s.getBytes(UTF_16LE)).hash());
      assertEquals(
          new Sink(4).putUnencodedChars(s).hash(), new Sink(4).putString(s, UTF_16LE).hash());
    }
  }

  public void testFloat() {
    Sink sink = new Sink(4);
    sink.putFloat(Float.intBitsToFloat(0x04030201));
    HashCode unused = sink.hash();
    sink.assertInvariants(4);

      assertTrue(item + " must be equivalent to itself", equivalence.equivalent(item, item));
      assertEquals(
          "the hash of " + item + " must be consistent",
          equivalence.hash(item),
          equivalence.hash(item));
    }
  }

 * following three expressions all generate colliding hash codes:
 *
 * {@snippet :
 * newHasher().putByte(b1).putByte(b2).putByte(b3).hash()
 * newHasher().putByte(b1).putBytes(new byte[] { b2, b3 }).hash()
 * newHasher().putBytes(new byte[] { b1, b2, b3 }).hash()
 * }
 *
 * <p>If you wish to avoid this, you should either prepend or append the size of each chunk. Keep in

    void testNTOWFv1() {
        byte[] hash = NtlmPasswordAuthentication.nTOWFv1("password");
        assertNotNull(hash);
        assertEquals(16, hash.length);
    }

    // Test nTOWFv2
    @Test
    void testNTOWFv2() {
        byte[] hash = NtlmPasswordAuthentication.nTOWFv2("DOMAIN", "user", "password");
        assertNotNull(hash);
        assertEquals(16, hash.length);
    }

    // Test unescape method

	for _, testcase := range []struct {
		config      string
		expectedErr bool
		hash        string
	}{
		{
			config:      "testdata/config/1.yaml",
			expectedErr: false,
			hash:        "hash:02bf70285dc71f76",
		},
		{
			config:      "testdata/config/2.yaml",
			expectedErr: false,
			hash:        "hash:676d2da00f71f205",
		},
		{
			config:      "testdata/config/invalid.yaml",
			expectedErr: true,

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