// Verify machineId part (should be truncated)
        byte[] expectedMachineId = new byte[32];
        for (int i = 0; i < 32; i++) {
            expectedMachineId[i] = (byte) i;
        }
        byte[] actualMachineId = new byte[32];
        System.arraycopy(value, 16, actualMachineId, 0, 32);
        assertArrayEquals(expectedMachineId, actualMachineId);
    }

	},
	{
		ObjectKey:  [32]byte{},
		ObjectInfo: ObjectInfo{ETag: "916516b396f0f4d4f2a0e7177557bec4-738"},
		ETag:       "916516b396f0f4d4f2a0e7177557bec4-738",
	},
	{
		ObjectKey:  [32]byte{},
		ObjectInfo: ObjectInfo{ETag: "916516b396f0f4d4f2a0e7177557bec4-Q"},
		ETag:       "",
		ShouldFail: true, // Q is not a number
	},
	{
		ObjectKey:  [32]byte{},

        // When
        int bytesWritten = request.writeBytesWireFormat(buffer, offset);

        // Then
        assertEquals(32, bytesWritten);

        // Verify structure size (32)
        assertEquals(32, SMBUtil.readInt2(buffer, offset));

        // Verify notify flags
        assertEquals(Smb2ChangeNotifyRequest.SMB2_WATCH_TREE, SMBUtil.readInt2(buffer, offset + 2));

  }

  public void testAscending() {
    // Test 32 byte arrays of ascending.
    byte[] ascending = new byte[32];
    for (int i = 0; i < 32; i++) {
      ascending[i] = (byte) i;
    }
    assertCrc(0x46dd794e, ascending);
  }

  public void testDescending() {
    // Test 32 byte arrays of descending.
    byte[] descending = new byte[32];
    for (int i = 0; i < 32; i++) {
      descending[i] = (byte) (31 - i);
    }

            bb.putLong(5000L);
            bb.putLong(2500L);
            bb.putLong(2500L);
            bb.putInt(16);
            bb.putInt(1024);

            // When
            int bytesConsumed = fileFsFullSizeInfo.decode(buffer, offset, 32);

            // Then
            assertEquals(32, bytesConsumed);

    return "Hashing.fingerprint2011()";
  }

  // End of public functions.

  @VisibleForTesting
  static long fingerprint(byte[] bytes, int offset, int length) {
    long result;

    if (length <= 32) {
      result = murmurHash64WithSeed(bytes, offset, length, K0 ^ K1 ^ K2);
    } else if (length <= 64) {
      result = hashLength33To64(bytes, offset, length);
    } else {

   *
   * @since 18.0
   */
  public static HashFunction crc32c() {
    return Crc32cHashFunction.CRC_32_C;
  }

  /**
   * Returns a hash function implementing the CRC-32 checksum algorithm (32 hash bits).
   *
   * <p>To get the {@code long} value equivalent to {@link Checksum#getValue()} for a {@code
   * HashCode} produced by this function, use {@link HashCode#padToLong()}.
   *

        return (src[srcIndex] & 0xFF) + ((src[srcIndex + 1] & 0xFF) << 8);
    }

    /**
     * Reads a 32-bit integer value from a byte array in little-endian format
     * @param src the source byte array
     * @param srcIndex the starting index in the source array
     * @return the 32-bit integer value
     */
    public static int readInt4(final byte[] src, final int srcIndex) {

    return (int) (links[entry] >>> 32);
  }

  private int getSuccessor(int entry) {
    return (int) links[entry];
  }

  private void setSuccessor(int entry, int succ) {
    long succMask = (~0L) >>> 32;
    links[entry] = (links[entry] & ~succMask) | (succ & succMask);
  }

  private void setPredecessor(int entry, int pred) {
    long predMask = (~0L) << 32;

    public void testGenerateRandomKey() {
        byte[] key1 = keyManager.generateRandomKey(32);
        byte[] key2 = keyManager.generateRandomKey(32);

        assertNotNull(key1, "Should generate key 1");
        assertNotNull(key2, "Should generate key 2");
        assertEquals(32, key1.length, "Key 1 should have correct length");
        assertEquals(32, key2.length, "Key 2 should have correct length");