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

        b[off + 0] = (byte) SessionServicePacket.SESSION_MESSAGE;
        b[off + 1] = (byte) 0x00;
        b[off + 2] = (byte) (len >> 8 & 0xFF);
        b[off + 3] = (byte) (len & 0xFF);

        out.write(b, off, 4 + len);
    }

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

    /**

/** Benchmark for {@code BaseEncoding} performance. */
@NullUnmarked
public class BaseEncodingBenchmark {
  private static final int INPUTS_COUNT = 0x1000;
  private static final int INPUTS_MASK = 0xFFF;

  enum EncodingOption {
    BASE64(BaseEncoding.base64()),
    BASE64_URL(BaseEncoding.base64Url()),
    BASE32(BaseEncoding.base32()),
    BASE32_HEX(BaseEncoding.base32Hex()),
    BASE16(BaseEncoding.base16());

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

        pipeData = data;
        pipeDataOff = off;
        pipeDataLen = len;
        command = SMB_COM_TRANSACTION;
        subCommand = TRANS_TRANSACT_NAMED_PIPE;
        maxParameterCount = 0;
        maxDataCount = 0xFFFF;
        maxSetupCount = (byte) 0x00;
        setupCount = 2;
        name = "\\PIPE\\";
    }

    @Override
    int writeSetupWireFormat(final byte[] dst, int dstIndex) {
        dst[dstIndex] = subCommand;

      "description": "invalid question (not related to GORM or described in document or not enough information provided)"
    },
    "with_playground": {
      "name": "type:with reproduction steps",
      "colour": "#00ff00",
      "description": "with reproduction steps"
    },
    "without_playground": {
      "name": "type:missing reproduction steps",
      "colour": "#CF2E1F",
      "description": "missing reproduction steps"
    },

            bufferIndex += 14;
            e.type = readInt2(buffer, bufferIndex);
            bufferIndex += 2;
            int off = readInt4(buffer, bufferIndex);
            bufferIndex += 4;
            off = (off & 0xFFFF) - converter;
            off = start + off;
            e.remark = readString(buffer, off, 128, false);

            if (LogStream.level >= 4) {
                log.println(e);
            }
        }

        // Test maximum unsigned 16-bit value (65535)
        SMBUtil.writeInt2(0xFFFF, buffer, 0);
        TransPeekNamedPipeResponse response2 = new TransPeekNamedPipeResponse(mockConfig);
        response2.readParametersWireFormat(buffer, 0, 6);
        assertEquals(0xFFFF, response2.getAvailable());
    }

    @Test
    @DisplayName("Test large buffer handling")