0x13579bdf,
              null,
              "df9b5713"),
          new ExpectedHashCode(
              new byte[] {(byte) 0xcd, (byte) 0xab, (byte) 0x00, (byte) 0x00},
              0x0000abcd,
              null,
              "cdab0000"),
          new ExpectedHashCode(
              new byte[] {
                (byte) 0xef, (byte) 0xcd, (byte) 0xab, (byte) 0x00,

                (byte) 0xCC, (byte) 0xDD, (byte) 0xEE, (byte) 0xFF, 0x00 };

        Smb2LeaseKey key = new Smb2LeaseKey(testBytes);
        byte[] buffer = new byte[20];

        key.encode(buffer, 2);

        for (int i = 0; i < 16; i++) {
            assertEquals(testBytes[i], buffer[i + 2]);
        }
    }

    @Test
    @DisplayName("Should implement equals correctly")
    void testEquals() {

        offset += 4;
        sourceBuffer[offset++] = (byte) 1; // deletePending = true
        sourceBuffer[offset++] = (byte) 0; // directory = false

        // Decode to set state
        fileStandardInfo.decode(sourceBuffer, 0, sourceBuffer.length);

        // Now test encode
        byte[] destinationBuffer = new byte[30]; // Extra space
        int dstIndex = 3; // Start at offset 3

    @DisplayName("Hex Conversion Tests")
    class HexConversionTests {

        @Test
        @DisplayName("Various byte values are converted to uppercase hex")
        void testHexConversion() {
            byte[] challenge = new byte[] { (byte) 0x00, (byte) 0x0F, (byte) 0x10, (byte) 0x7F, (byte) 0x80, (byte) 0xFF };
            UniAddress dc = mock(UniAddress.class);
            when(dc.toString()).thenReturn("DC");

        final byte[] ciphertext;
        final byte[] authTag;

        EncryptionResult(byte[] ciphertext, byte[] authTag) {
            this.ciphertext = ciphertext;
            this.authTag = authTag;
        }
    }

    /**
     * Encrypt using AES-GCM with constant-time operations
     */

        verifyNfold("password", 7,
                new byte[] { (byte) 0x78, (byte) 0xa0, (byte) 0x7b, (byte) 0x6c, (byte) 0xaf, (byte) 0x85, (byte) 0xfa });

        // 64-fold("Rough Consensus, and Running Code")
        verifyNfold("Rough Consensus, and Running Code", 8,
                new byte[] { (byte) 0xbb, (byte) 0x6e, (byte) 0xd3, (byte) 0x08, (byte) 0x70, (byte) 0xb7, (byte) 0xf0, (byte) 0xe0 });

        // 64-fold("kerberos")

     */
    public static byte[] calculateMacHMACAES(int usage, KerberosKey baseKey, byte[] input) throws GeneralSecurityException {
        byte[] cst = { (byte) (usage >> 24 & 0xFF), (byte) (usage >> 16 & 0xFF), (byte) (usage >> 8 & 0xFF), (byte) (usage & 0xFF),
                (byte) 0x99 };

        byte[] output = new byte[12];
        byte[] dk = deriveKeyAES(baseKey, cst); // Checksum key
        try {

     */
    @Test
    public void testInvalidBufferSizeRejection() {
        // Given - Buffers with various invalid sizes
        byte[] tooSmall = new byte[1024];
        byte[] tooLarge = new byte[SmbComTransaction.TRANSACTION_BUF_SIZE + 1];
        byte[] empty = new byte[0];

        // When - Try to release invalid buffers
        assertDoesNotThrow(() -> {
            BufferCache.releaseBuffer(tooSmall);

        FileRenameInformation2 info = new FileRenameInformation2(unicodeFileName, false);

        byte[] buffer = new byte[200];
        int bytesWritten = info.encode(buffer, 0);

        // Verify the encoded data
        int nameLength = SMBUtil.readInt4(buffer, 16);
        byte[] nameBytes = new byte[nameLength];
        System.arraycopy(buffer, 20, nameBytes, 0, nameLength);

        void testWriteBytesWireFormat() {
            byte[] buffer = new byte[1024];
            int result = response.writeBytesWireFormat(buffer, 0);
            assertEquals(0, result);
        }

        @Test
        @DisplayName("Should return 0 regardless of buffer position")
        void testWriteBytesWireFormatDifferentPosition() {
            byte[] buffer = new byte[1024];