// Test with buffer and length larger than needed
        byte[] buffer = new byte[100];

        // Fill test pattern
        for (int i = 0; i < buffer.length; i++) {
            buffer[i] = (byte) (i % 256);
        }

        int bytesConsumed = response.decode(buffer, 0, 50);

        assertEquals(28, bytesConsumed, "Should consume exactly 28 bytes regardless of extra length");

        System.arraycopy(testMac, 0, src, srcIndex + 19, 6);

        // Statistics
        byte[] stats = { 0x00, 0x01, 0x02, 0x03, 0x04, 0x05 };
        System.arraycopy(stats, 0, src, srcIndex + 25, 6);

        int result = response.readRDataWireFormat(src, srcIndex);
        assertEquals(31, result);

        // Verify queryAddress was updated
        assertTrue(mockQueryAddress.isDataFromNodeStatus);

        byte[] largeKey = new byte[256];
        for (int i = 0; i < largeKey.length; i++) {
            largeKey[i] = (byte) (i % 256);
        }
        serverData.encryptionKey = largeKey;
        serverData.encryptionKeyLength = largeKey.length;

        assertEquals(256, serverData.encryptionKey.length);
        assertEquals(256, serverData.encryptionKeyLength);

    assertEquals(8581389452482819506L, fingerprint("test".getBytes(UTF_8)));
    // 32 characters long
    assertEquals(-4196240717365766262L, fingerprint(Strings.repeat("test", 8).getBytes(UTF_8)));
    // 256 characters long
    assertEquals(3500507768004279527L, fingerprint(Strings.repeat("test", 64).getBytes(UTF_8)));
  }

  public void testStringsConsistency() {

type BitrotAlgorithm uint

const (
	// SHA256 represents the SHA-256 hash function
	SHA256 BitrotAlgorithm = 1 + iota
	// HighwayHash256 represents the HighwayHash-256 hash function
	HighwayHash256
	// HighwayHash256S represents the Streaming HighwayHash-256 hash function
	HighwayHash256S
	// BLAKE2b512 represents the BLAKE2b-512 hash function
	BLAKE2b512
)

     *
     * @param cause the underlying exception
     * @return the real message
     */
    protected static String getRealMessage(final SQLException cause) {
        final StringBuilder buf = new StringBuilder(256);
        buf.append(cause.getMessage()).append(" : [");
        SQLException next = cause.getNextException();
        while (next != null) {

    int hashBytes = hashbits / 8;

    byte[] key = new byte[256];
    byte[] hashes = new byte[hashBytes * 256];

    // Hash keys of the form {}, {0}, {0,1}, {0,1,2}... up to N=255,using 256-N as the seed
    for (int i = 0; i < 256; i++) {
      key[i] = (byte) i;
      int seed = 256 - i;
      byte[] hash = hashFunction.hash(Arrays.copyOf(key, i), seed);

  private static final int CRC32C_GENERATOR_FLIPPED = Integer.reverse(CRC32C_GENERATOR);

  public void testCrc32cByteTable() {
    // See Hacker's Delight 2nd Edition, Figure 14-7.
    int[] expected = new int[256];
    for (int i = 0; i < expected.length; i++) {
      int crc = i;
      for (int j = 7; j >= 0; j--) {
        int mask = -(crc & 1);
        crc = (crc >>> 1) ^ (CRC32C_GENERATOR_FLIPPED & mask);
      }

        assertEquals("31f30ddbcb1bf8446576f0e64aa4c88a9f055e3c", MessageDigestUtil.digest("SHA-1", text));
        assertEquals("ecb666d778725ec97307044d642bf4d160aabb76f56c0069c71ea25b1e926825", MessageDigestUtil.digest("SHA-256", text));

        try {
            MessageDigestUtil.digest(null, text);
            assertTrue(false);
        } catch (final EmptyArgumentException e) {
            assertTrue(true);
        }
        try {

  CRC32(Hashing.crc32()),
  GOOD_FAST_HASH_32(Hashing.goodFastHash(32)),
  GOOD_FAST_HASH_64(Hashing.goodFastHash(64)),
  GOOD_FAST_HASH_128(Hashing.goodFastHash(128)),
  GOOD_FAST_HASH_256(Hashing.goodFastHash(256)),
  MD5(Hashing.md5()),
  MURMUR3_128(Hashing.murmur3_128()),
  MURMUR3_32(Hashing.murmur3_32()),
  MURMUR3_32_FIXED(Hashing.murmur3_32_fixed()),
  SHA1(Hashing.sha1()),
  SHA256(Hashing.sha256()),