new ValidateNegotiateInfoRequest(0xFFFFFFFF, defaultClientGuid, DEFAULT_SECURITY_MODE, defaultDialects);

        byte[] buffer = new byte[request.size()];
        request.encode(buffer, 0);

        // Verify max capabilities value (comparing as unsigned long)
        assertEquals(0xFFFFFFFFL, SMBUtil.readInt4(buffer, 0) & 0xFFFFFFFFL);
    }

    @Test

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

    }

    @ParameterizedTest
    @ValueSource(longs = { 0L, 1L, 0xFFFFFFFFL, 0x12345678L, 0x80000000L })
    void testWriteReadInt4RoundTrip(long input) {
        byte[] buffer = new byte[8];
        SMBUtil.writeInt4(input, buffer, 0);
        int result = SMBUtil.readInt4(buffer, 0);
        assertEquals((int) (input & 0xFFFFFFFFL), result);
    }

    @ParameterizedTest

     * @return the number of bytes written (8)
     */
    public static int enc_uint64be(final long l, final byte[] dst, final int di) {
        enc_uint32be((int) (l & 0xFFFFFFFFL), dst, di + 4);
        enc_uint32be((int) (l >> 32L & 0xFFFFFFFFL), dst, di);
        return 8;
    }

    /**
     * Encodes a 64-bit unsigned integer in little-endian byte order.
     *
     * @param l the long value to encode

     * @return the number of bytes written (8)
     */
    public static int enc_uint64be(final long l, final byte[] dst, final int di) {
        enc_uint32be((int) (l & 0xFFFFFFFFL), dst, di + 4);
        enc_uint32be((int) (l >> 32L & 0xFFFFFFFFL), dst, di);
        return 8;
    }

    /**
     * Encodes a 64-bit unsigned integer in little-endian byte order.
     *
     * @param l the long value to encode

    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;
                }
            }

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

        }

        @ParameterizedTest
        @DisplayName("Should encode consistently with various flag values")
        @ValueSource(ints = { 0, 1, 2, 4, 16, 0xFF, 0xFFFF, 0xFFFFFF, 0x7FFFFFFF, -1 })
        void testEncodingWithVariousFlags(int flags) {
            lock = new Smb2Lock(1024L, 2048L, flags);
            int encoded = lock.encode(buffer, 0);

            assertEquals(24, encoded);