buffer.put((byte) 0x01); // SubAuthorityCount
        buffer.put(new byte[] { 0, 0, 0, 0, 0, 2 }); // IdentifierAuthority
        buffer.putInt(0); // SubAuthority

        // DACL at offset 60
        buffer.position(60);
        buffer.put((byte) 0x02); // AclRevision
        buffer.put((byte) 0x00); // Padding
        buffer.putShort((short) 8); // AclSize
        buffer.putShort((short) 0); // AceCount

            buffer[16 + i] = expectedData[i];
        }

        // Set header values
        SMBUtil.writeInt4(0x100, buffer, 0);
        SMBUtil.writeInt4(0x200, buffer, 4);
        SMBUtil.writeInt4(0x300, buffer, 8);
        SMBUtil.writeInt4(0x400, buffer, 12);

        // Decode
        response.decode(buffer, 0, 32);

        // Verify data integrity

    private const val UNICODE_2 = 0x1a5

    /** Arbitrary code point that's 3 bytes in UTF-8 and valid in IdnaMappingTable.txt. */
    private const val UNICODE_3 = 0x2202

    /** Arbitrary code point that's 4 bytes in UTF-8 and valid in IdnaMappingTable.txt. */
    private const val UNICODE_4 = 0x1d11e

    /**

    }

    @Test
    void testWriteHeaderReadHeader() {
        byte[] buffer = new byte[32];
        smb.command = ServerMessageBlock.SMB_COM_NEGOTIATE;
        smb.flags = (byte) 0x18;
        smb.flags2 = 0x0001;
        smb.tid = 1;
        smb.pid = 2;
        smb.uid = 3;
        smb.mid = 4;

        smb.writeHeaderWireFormat(buffer, 0);

        TestServerMessageBlock readSmb = new TestServerMessageBlock();

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

        // Then
        assertEquals(4, bytesWritten);

        // Expected wire format: [0x04, 0x00, 0x00, 0x00]
        byte[] expected = new byte[] { 0x04, 0x00, 0x00, 0x00 };
        assertArrayEquals(expected, buffer);
    }

    @Test
    @DisplayName("Should always return 0 for readBytesWireFormat")
    void testReadBytesWireFormat() {

    @DisplayName("Should support AES-256 cipher constants")
    void testAES256CipherConstants() {
        // Verify AES-256 constants are defined
        assertEquals(0x0003, Smb2EncryptionContext.CIPHER_AES_256_CCM, "AES-256-CCM constant should be defined");
        assertEquals(0x0004, Smb2EncryptionContext.CIPHER_AES_256_GCM, "AES-256-GCM constant should be defined");

        // Test creating context with AES-256 cipher IDs

        }

        @Test
        @DisplayName("Should handle ciphers with maximum value")
        void testMaximumCipherValues() throws SMBProtocolDecodingException {
            int[] ciphers = { 0xFFFF, 0x0000, 0x7FFF };
            EncryptionNegotiateContext originalContext = new EncryptionNegotiateContext(mockConfig, ciphers);

            int encoded = originalContext.encode(buffer, 0);

        // recordType (2 bytes)
        src[srcIndex + 2] = 0x00;
        src[srcIndex + 3] = 0x20; // NB (0x0020)
        // recordClass (2 bytes)
        src[srcIndex + 4] = 0x00;
        src[srcIndex + 5] = 0x01; // IN (0x0001)
        // ttl (4 bytes)
        src[srcIndex + 6] = 0x00;
        src[srcIndex + 7] = 0x00;
        src[srcIndex + 8] = 0x00;
        src[srcIndex + 9] = 0x00;
        // rDataLength (2 bytes)

            }
        } else {
            this.createDisposition = FILE_OPEN;
        }

        if ((createOptions & 0x0001) == 0) {
            this.createOptions = createOptions | 0x0040;
        } else {
            this.createOptions = createOptions;
        }
        this.impersonationLevel = 0x02; // As seen on NT :~)
        this.securityFlags = (byte) 0x03; // SECURITY_CONTEXT_TRACKING | SECURITY_EFFECTIVE_ONLY
    }

        assertEquals(expectedHigh, buffer[offset + 3]);
    }

    private static Stream<Arguments> provideFidTestCases() {
        return Stream.of(Arguments.of(0x0000, (byte) 0x00, (byte) 0x00), Arguments.of(0x00FF, (byte) 0xFF, (byte) 0x00),
                Arguments.of(0xFF00, (byte) 0x00, (byte) 0xFF), Arguments.of(0xFFFF, (byte) 0xFF, (byte) 0xFF),
                Arguments.of(0x1234, (byte) 0x34, (byte) 0x12));
    }

    @Test