assertEquals(0xFFFF, pdis.readUnsignedShort());
    }

    @Test
    public void testReadUnsignedInt() throws IOException {
        // Little-endian 0xFFFFFFFF -> 0xFF 0xFF 0xFF 0xFF
        byte[] data = new byte[] { (byte) 0xFF, (byte) 0xFF, (byte) 0xFF, (byte) 0xFF };
        PacDataInputStream pdis = createInputStream(data);

    void testFaultCodeValueRanges() {
        // Standard fault codes (0x00000000 - 0x0000FFFF range)
        assertTrue(DcerpcError.DCERPC_FAULT_OTHER >= 0 && DcerpcError.DCERPC_FAULT_OTHER <= 0x0000FFFF,
                "DCERPC_FAULT_OTHER should be in standard range");
        assertTrue(DcerpcError.DCERPC_FAULT_ACCESS_DENIED >= 0 && DcerpcError.DCERPC_FAULT_ACCESS_DENIED <= 0x0000FFFF,
                "DCERPC_FAULT_ACCESS_DENIED should be in standard range");

        // Test with max int value (unsigned interpretation)
        buffer.putInt(0, 0xFFFFFFFF);
        assertEquals(0xFFFFFFFF, NtlmMessage.readULong(data, 0), "Should read max ULong correctly.");

        // Test with a negative int (should be interpreted as unsigned positive)
        buffer.putInt(0, -1); // -1 is 0xFFFFFFFF
        assertEquals(0xFFFFFFFF, NtlmMessage.readULong(data, 0), "Should interpret -1 as unsigned max ULong.");
    }

        SMBUtil.writeInt2(16, buffer, 0);
        buffer[2] = (byte) 0xFF; // Max share type
        buffer[3] = 0;
        SMBUtil.writeInt4(0xFFFFFFFF, buffer, 4); // Max share flags
        SMBUtil.writeInt4(0xFFFFFFFF, buffer, 8); // Max capabilities
        SMBUtil.writeInt4(0xFFFFFFFF, buffer, 12); // Max access

        // When
        int bytesRead = response.readBytesWireFormat(buffer, 0);

        // Then

    void testWriteSetupWireFormatBufferBoundary() {
        notifyChange = new NtTransNotifyChange(mockConfig, 0xFFFF, 0xFFFFFFFF, true);
        byte[] dst = new byte[8]; // Exact size needed

        int bytesWritten = notifyChange.writeSetupWireFormat(dst, 0);

        assertEquals(8, bytesWritten);
        assertEquals(0xFFFFFFFF, SMBUtil.readInt4(dst, 0));
        assertEquals(0xFFFF, SMBUtil.readInt2(dst, 4));

    public boolean containsKey(final Object key) {
        final Entry<K, V>[] tbl = mapTable;
        if (key != null) {
            final int hashCode = key.hashCode();
            final int index = (hashCode & 0x7FFFFFFF) % tbl.length;
            for (Entry<K, V> e = tbl[index]; e != null; e = e.next) {
                if (e.hashCode == hashCode && key.equals(e.key)) {
                    return true;
                }
            }

        transaction.setTotalParameterCount(0xFFFFFFFF);
        transaction.setTotalDataCount(0xFFFFFFFF);
        transaction.setMaxParameterCount(0xFFFFFFFF);
        transaction.setMaxDataCountForTest(0xFFFFFFFF);
        transaction.setParameterCount(0xFFFFFFFF);
        transaction.setParameterOffset(0xFFFFFFFF);
        transaction.setDataCount(0xFFFFFFFF);
        transaction.setDataOffset(0xFFFFFFFF);

                domain = suppliedDomain.toUpperCase().getBytes(getOEMEncoding());
            } else {
                flags &= NTLMSSP_NEGOTIATE_OEM_DOMAIN_SUPPLIED ^ 0xffffffff;
            }
            byte[] workstation = {};
            if (suppliedWorkstation != null && suppliedWorkstation.length() != 0) {
                hostInfo = true;

        command = SMB_COM_READ_ANDX;
        openTimeout = 0xFFFFFFFF;
    }

    SmbComReadAndX(final int fid, final long offset, final int maxCount, final ServerMessageBlock andx) {
        super(andx);
        this.fid = fid;
        this.offset = offset;
        this.maxCount = minCount = maxCount;
        command = SMB_COM_READ_ANDX;
        openTimeout = 0xFFFFFFFF;
    }

                Arguments.of(0xFFFFFFFF, "All bits set"));
    }

    @Test
    @DisplayName("Test writeParametersWireFormat buffer boundary")
    void testWriteParametersWireFormatBufferBoundary() {
        querySecurityDesc = new NtTransQuerySecurityDesc(mockConfig, 0xFFFF, 0xFFFFFFFF);
        byte[] dst = new byte[8];