}

    @Test
    @DisplayName("Test default buffer size constant")
    void testBufferSizeConstant() {
        assertEquals(0xFFFF, SmbComTransaction.TRANSACTION_BUF_SIZE, "TRANSACTION_BUF_SIZE should be 0xFFFF");
    }

    @Test
    @DisplayName("Test transaction subcommand constants")
    void testSubcommandConstants() {
        // Test Trans2 subcommands

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

        // Assert
        assertNotNull(trans);
        assertEquals(0, trans.maxParameterCount);
        assertEquals(0xFFFF, trans.maxDataCount);
        assertEquals(0x00, trans.maxSetupCount);
        assertEquals(2, trans.setupCount);
        assertEquals("\\PIPE\\", trans.name);
    }

    @Test

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

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

    @Test
    void testDecNdrStringInvalidConformance() {
        // Simulate a string with invalid size
        ndrBuffer.setIndex(0);
        Encdec.enc_uint32le(0xFFFF + 1, buffer, 0); // len = 0xFFFF + 1
        Encdec.enc_uint32le(0, buffer, 4);
        Encdec.enc_uint32le(0xFFFF + 1, buffer, 8);

        ndrBuffer.setIndex(0);
        NdrException thrown = assertThrows(NdrException.class, () -> {
            ndrBuffer.dec_ndr_string();

        assertEquals(0xFFFFFFFF, transCallNamedPipe.timeout);
        assertEquals(0, transCallNamedPipe.maxParameterCount);
        assertEquals(0xFFFF, transCallNamedPipe.maxDataCount);
        assertEquals((byte) 0x00, transCallNamedPipe.maxSetupCount);
        assertEquals(2, transCallNamedPipe.setupCount);
    }

    @Test

    void testReadBytesWireFormatNegativeStructureSize() {
        byte[] buffer = new byte[1024];
        int bufferIndex = 0;

        // Set structure size to -1 (0xFFFF when read as unsigned)
        SMBUtil.writeInt2(0xFFFF, buffer, bufferIndex);

        SMBProtocolDecodingException exception =
                assertThrows(SMBProtocolDecodingException.class, () -> response.readBytesWireFormat(buffer, bufferIndex),

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

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

    assertThat(escaper.escape("The Quick Brown Fox")).isEqualTo("The Quick Brown Fox");
  }

  public void testBuilderInitialStateNoneUnsafe() {
    // No characters are unsafe by default (safeMin == 0, safeMax == 0xFFFF).
    Escaper escaper = Escapers.builder().setUnsafeReplacement("X").build();
    assertThat(escaper.escape("\0\uFFFF")).isEqualTo("\0\uFFFF");
  }

  public void testBuilderRetainsState() {

     *
     * @param server the server name to enumerate DFS roots from
     */
    public MsrpcDfsRootEnum(final String server) {
        super(server, 200, 0xFFFF, new netdfs.DfsEnumStruct(), new NdrLong(0));
        info.level = level;
        info.e = new netdfs.DfsEnumArray200();
        ptype = 0;
        flags = DCERPC_FIRST_FRAG | DCERPC_LAST_FRAG;
    }

    /**