}

            // there seems to be a bug with some servers that causes corruption if using signatures + CAP_LARGE_WRITE
            if (th.hasCapability(SmbConstants.CAP_LARGE_WRITEX) && !th.areSignaturesActive()) {
                this.writeSize = Math.min(th.getConfig().getSendBufferSize() - 70, 0xFFFF - 70);
            }

            this.fp = 0L;

        }

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

            this.largeReadX = true;
            this.readSizeFile =
                    Math.min(th.getConfig().getReceiveBufferSize() - 70, th.areSignaturesActive() ? 0xFFFF - 70 : 0xFFFFFF - 70);
            log.debug("Enabling LARGE_READX with " + this.readSizeFile);
        } else {
            log.debug("LARGE_READX disabled");
            this.readSizeFile = this.readSize;
        }

    void testNegativeFidValue() {
        int fid = -1; // Will be treated as 0xFFFF in unsigned 16-bit
        notifyChange = new NtTransNotifyChange(mockConfig, fid, FILE_NOTIFY_CHANGE_FILE_NAME, false);
        byte[] dst = new byte[10];

        notifyChange.writeSetupWireFormat(dst, 0);

        // Should write as 0xFFFF (65535 in unsigned)
        assertEquals(0xFFFF, SMBUtil.readInt2(dst, 4));
    }

    @Test

        buffer.putShort(0, (short) 0xFFFF);
        assertEquals(0xFFFF, NtlmMessage.readUShort(data, 0), "Should read max UShort correctly.");

        // Test with a negative short (should be interpreted as unsigned positive)
        buffer.putShort(0, (short) -1); // -1 is 0xFFFF
        assertEquals(0xFFFF, NtlmMessage.readUShort(data, 0), "Should interpret -1 as unsigned max UShort.");
    }

                final int _name_bufferi = _src.index;
                _src.advance(2 * _name_bufferl);

                if (this.name.buffer == null) {
                    if (_name_buffers < 0 || _name_buffers > 0xFFFF) {
                        throw new NdrException(NdrException.INVALID_CONFORMANCE);
                    }
                    this.name.buffer = new short[_name_buffers];
                }

        int fid = -1; // Will be treated as 0xFFFF in unsigned 16-bit
        querySecurityDesc = new NtTransQuerySecurityDesc(mockConfig, fid, OWNER_SECURITY_INFORMATION);
        byte[] dst = new byte[10];

        querySecurityDesc.writeParametersWireFormat(dst, 0);

        // Should write as 0xFFFF (65535 in unsigned)
        assertEquals(0xFFFF, SMBUtil.readInt2(dst, 0));
    }

    @Test

                final int _ss = _src.dec_ndr_long();
                final int _si = _src.index;
                _src.advance(4 * _ss);

                if (this.s == null) {
                    if (_ss < 0 || _ss > 0xFFFF) {
                        throw new NdrException(NdrException.INVALID_CONFORMANCE);
                    }
                    this.s = new DfsInfo1[_ss];
                }
                _src = _src.derive(_si);

            final int _nodes = 6;
            final int _nodei = _src.index;
            _src.advance(1 * _nodes);

            if (node == null) {
                if (_nodes < 0 || _nodes > 0xFFFF) {
                    throw new NdrException(NdrException.INVALID_CONFORMANCE);
                }
                node = new byte[_nodes];
            }
            _src = _src.derive(_nodei);

        long data4 = bb2.getLong();

        // Construct UUID from components - Java UUID expects big-endian representation
        long mostSig = ((long) data1 << 32) | ((long) (data2 & 0xFFFF) << 16) | (data3 & 0xFFFF);
        long leastSig = data4;

        this.guid = new UUID(mostSig, leastSig);
    }

    /**
     * Create a handle GUID from existing UUID
     * @param uuid the UUID to wrap
     */