}
    return HashCode.fromBytes(bb.array());
  }

  public void testParanoid() {
    HashFn hf =
        new HashFn() {
          @Override
          public byte[] hash(byte[] input, int seed) {
            Hasher hasher = murmur3_128(seed).newHasher();
            byteArrayFunnel().funnel(input, hasher);
            return hasher.hash().asBytes();
          }
        };

    @CanIgnoreReturnValue
    @Override
    public Hasher putInt(int i) {
      update(4, i);
      return this;
    }

    @CanIgnoreReturnValue
    @Override
    public Hasher putLong(long l) {
      update(4, (int) l);
      update(4, l >>> 32);
      return this;
    }

    @CanIgnoreReturnValue
    @Override
    public Hasher putChar(char c) {
      update(2, c);
      return this;

        assertEquals("s3://bucket.with.dots/path", wizardAction.convertCrawlingPath("s3://bucket.with.dots/path"));
        assertEquals("s3://bucket-with-dashes/path", wizardAction.convertCrawlingPath("s3://bucket-with-dashes/path"));
        assertEquals("s3://123bucket/path", wizardAction.convertCrawlingPath("s3://123bucket/path"));
    }

    @Test

  }

  public void testParanoid() {
    HashFn hf =
        new HashFn() {
          @Override
          public byte[] hash(byte[] input, int seed) {
            Hasher hasher = murmur3_32(seed).newHasher();
            byteArrayFunnel().funnel(input, hasher);
            return hasher.hash().asBytes();
          }
        };

      checkNotDone();
      checkNotNull(bytes);
      mac.update(bytes);
    }

    private void checkNotDone() {
      checkState(!done, "Cannot re-use a Hasher after calling hash() on it");
    }

    @Override
    public HashCode hash() {
      checkNotDone();
      done = true;
      return HashCode.fromBytesNoCopy(mac.doFinal());
    }
  }

    HashCode hash31 = HashCode.fromInt(31);
    HashCode hash32 = HashCode.fromInt(32);
    assertEquals(hash32, Hashing.combineUnordered(ImmutableList.of(hash32)));
    assertEquals(HashCode.fromInt(64), Hashing.combineUnordered(ImmutableList.of(hash32, hash32)));
    assertEquals(
        HashCode.fromInt(96), Hashing.combineUnordered(ImmutableList.of(hash32, hash32, hash32)));
    assertEquals(

    Hasher hasher = hmacMd5(MD5_KEY).newHasher();

    assertThat(
            hasher
                .putString("The quick brown fox jumps over the lazy dog", UTF_8)
                .hash()
                .toString())
        .isEqualTo("9753980fe94daa8ecaa82216519393a9");
    assertThrows(IllegalStateException.class, hasher::hash);
  }

  public void testToString() {
    byte[] keyData = "secret key".getBytes(UTF_8);

  }

  public void testParanoid() {
    HashFn hf =
        new HashFn() {
          @Override
          public byte[] hash(byte[] input, int seed) {
            Hasher hasher = murmur3_32(seed).newHasher();
            byteArrayFunnel().funnel(input, hasher);
            return hasher.hash().asBytes();
          }
        };

func (c ChecksumType) CanMerge() bool {
	return c.Is(ChecksumCRC64NVME) || c.Is(ChecksumCRC32C) || c.Is(ChecksumCRC32)
}

// Hasher returns a hasher corresponding to the checksum type.
// Returns nil if no checksum.
func (c ChecksumType) Hasher() hash.Hash {
	switch {
	case c.Is(ChecksumCRC32):
		return crc32.NewIEEE()
	case c.Is(ChecksumCRC32C):
		return crc32.New(crc32.MakeTable(crc32.Castagnoli))

	}
}

// KafkaSHA256 is a function that returns a crypto/sha256 hasher and should be used
// to create Client objects configured for SHA-256 hashing.
var KafkaSHA256 scram.HashGeneratorFcn = sha256.New

// KafkaSHA512 is a function that returns a crypto/sha512 hasher and should be used
// to create Client objects configured for SHA-512 hashing.
var KafkaSHA512 scram.HashGeneratorFcn = sha512.New