this.negotiatedFlags2 |= SmbConstants.FLAGS2_SECURITY_REQUIRE_SIGNATURES;
            }
        } else {
            this.negotiatedFlags2 &= 0xFFFF ^ SmbConstants.FLAGS2_SECURITY_SIGNATURES;
            this.negotiatedFlags2 &= 0xFFFF ^ SmbConstants.FLAGS2_SECURITY_REQUIRE_SIGNATURES;
        }

        if (log.isDebugEnabled()) {

            byte[] testBuffer = new byte[8];
            ByteBuffer bb = ByteBuffer.wrap(testBuffer).order(ByteOrder.LITTLE_ENDIAN);
            bb.putShort((short) 0xFFFE); // Max even pathConsumed
            bb.putShort((short) 0); // numReferrals
            bb.putShort((short) 0xFFFF); // Max tflags
            bb.putShort((short) 0); // tflags high bytes

            buffer.decode(testBuffer, 0, testBuffer.length);

                final int _arrayi = _src.index;
                _src.advance(4 * _arrays);

                if (array == null) {
                    if (_arrays < 0 || _arrays > 0xFFFF) {
                        throw new NdrException(NdrException.INVALID_CONFORMANCE);
                    }
                    array = new ShareInfo0[_arrays];
                }

        byte[] src = new byte[] {
                // 0x123456789ABCDEF0L
                (byte) 0xF0, (byte) 0xDE, (byte) 0xBC, (byte) 0x9A, (byte) 0x78, (byte) 0x56, (byte) 0x34, (byte) 0x12,
                // 0xFFFFFFFFFFFFFFFFL
                (byte) 0xFF, (byte) 0xFF, (byte) 0xFF, (byte) 0xFF, (byte) 0xFF, (byte) 0xFF, (byte) 0xFF, (byte) 0xFF,
                // 0x0000000000000000L

    static Stream<org.junit.jupiter.params.provider.Arguments> validInputs() {
        return Stream.of(org.junit.jupiter.params.provider.Arguments.of(0x0001, 0x00000000),
                org.junit.jupiter.params.provider.Arguments.of(0xFFFF, 0x12345678),
                org.junit.jupiter.params.provider.Arguments.of(-1, -123456));
    }

    @ParameterizedTest
    @MethodSource("validInputs")

        request.setCompletionFilter(0xFFF);

        // Second write
        byte[] buffer2 = new byte[512];
        request.writeBytesWireFormat(buffer2, 0);

        // Then
        assertEquals(0, SMBUtil.readInt2(buffer1, 2));
        assertEquals(0, SMBUtil.readInt4(buffer1, 24));
        assertEquals(0x0001, SMBUtil.readInt2(buffer2, 2));
        assertEquals(0xFFF, SMBUtil.readInt4(buffer2, 24));
    }

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

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

                new ValidateNegotiateInfoRequest(DEFAULT_CAPABILITIES, defaultClientGuid, 0xFFFF, defaultDialects);

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

        // Verify max security mode value (2 bytes)
        assertEquals(0xFFFF, SMBUtil.readInt2(buffer, 20) & 0xFFFF);
    }

    @Test
    @DisplayName("Test encode with all zero GUID")

            }

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

        assertArrayEquals(new byte[] { (byte) 0xFF, (byte) 0xFF }, dst, "Negative sid should wrap to 0xFFFF");
    }

    @Test
    void testWriteParameterWordsWithOffset() {
        byte[] dst = new byte[5];
        int written = instance.writeParameterWordsWireFormat(dst, 3);
        assertEquals(2, written);
        assertEquals((byte) (TEST_SID & 0xFF), dst[3]);
        assertEquals((byte) ((TEST_SID >> 8) & 0xFF), dst[4]);