// 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));

        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;

        byte[] buffer = new byte[256];
        long overflowSize = 0xFFFFFFFFL; // This will become -1 as signed int

        SMBUtil.writeInt2(0, buffer, 0);
        SMBUtil.writeUTime(0, buffer, 2);
        SMBUtil.writeInt4(overflowSize, buffer, 6);

        response.readParameterWordsWireFormat(buffer, 0);

        // 0xFFFFFFFF becomes -1 when interpreted as signed int
        assertEquals(-1L, response.getSize());

        // SubCommand should be TRANS_WAIT_NAMED_PIPE (0x53)
        assertEquals(SmbComTransaction.TRANS_WAIT_NAMED_PIPE, pipe.subCommand);

        // Timeout is set to 0xFFFFFFFF (-1 when cast to int)
        assertEquals(0xFFFFFFFF, pipe.timeout);

        // Max parameter and data counts should be 0
        assertEquals(0, pipe.maxParameterCount);
        assertEquals(0, pipe.maxDataCount);

            }
        }

        @Test
        @DisplayName("Unspecified TreeId should be 0xFFFFFFFF")
        void testUnspecifiedTreeId() {
            assertEquals(0xFFFFFFFF, Smb2Constants.UNSPECIFIED_TREEID, "Unspecified TreeId must be 0xFFFFFFFF");
            assertEquals(-1, Smb2Constants.UNSPECIFIED_TREEID, "Unspecified TreeId as signed int should be -1");
        }

        @Test

                    (byte) 0xFF, (byte) 0xFF, (byte) 0xFF, (byte) 0xFF, (byte) 0xFF, (byte) 0xFF, (byte) 0xFF };

    /**
     * Unspecified tree ID value
     */
    public static final int UNSPECIFIED_TREEID = 0xFFFFFFFF;

    /**
     * Unspecified session ID value
     */
    public static final long UNSPECIFIED_SESSIONID = 0xFFFFFFFFFFFFFFFFL;

    /**
     * SMB2 Channel constant for RDMA V1

                domain = suppliedDomainString.toUpperCase().getBytes(getOEMEncoding());
                size += domain.length;
            } else {
                flags &= NTLMSSP_NEGOTIATE_OEM_DOMAIN_SUPPLIED ^ 0xffffffff;
            }

            byte[] workstation = {};
            final String suppliedWorkstationString = getSuppliedWorkstation();