*/
    public InputStreamThread(final InputStream is, final Charset charset, final int bufferSize, final Consumer<String> outputCallback) {
        super("InputStreamThread");
        this.bufferSize = bufferSize;
        this.outputCallback = outputCallback;

        br = new BufferedReader(new InputStreamReader(is, charset));
    }

    /**

            return buf;
        }

        // Validate buffer size to prevent overflow
        int bufferSize = SmbComTransaction.TRANSACTION_BUF_SIZE;
        if (bufferSize < 0 || bufferSize > MAX_BUFFER_SIZE) {
            throw new IllegalStateException("Invalid buffer size: " + bufferSize);
        }

        return new byte[bufferSize];
    }

    static void getBuffers(final SmbComTransaction req, final SmbComTransactionResponse rsp) {

      }

      OPCODE_CONTROL_CLOSE -> {
        var code = CLOSE_NO_STATUS_CODE
        var reason = ""
        val bufferSize = controlFrameBuffer.size
        if (bufferSize == 1L) {
          throw ProtocolException("Malformed close payload length of 1.")
        } else if (bufferSize != 0L) {
          code = controlFrameBuffer.readShort().toInt()
          reason = controlFrameBuffer.readUtf8()

                int bufferType = pacStream.readInt();
                int bufferSize = pacStream.readInt();
                long bufferOffset = pacStream.readLong();

                if (bufferOffset % 8 != 0) {
                    throw new PACDecodingException("Unaligned buffer " + bufferType);
                }

                byte[] bufferData = new byte[bufferSize];

     * @return The buffer size
     */
    public int getBufferSize() {
        return bufferSize;
    }

    /**
     * Sets the buffer size for data transfers.
     *
     * @param bufferSize The buffer size
     */
    public void setBufferSize(final int bufferSize) {
        this.bufferSize = bufferSize;
    }

    /**
     * Gets the local IP address for passive mode FTP.
     *

        @DisplayName("Should handle maximum buffer index")
        void testMaxBufferIndex() throws SMBProtocolDecodingException {
            // Given
            int bufferSize = 10000;
            byte[] buffer = new byte[bufferSize];
            int bufferIndex = bufferSize - 4;
            SMBUtil.writeInt2(4, buffer, bufferIndex);
            SMBUtil.writeInt2(0, buffer, bufferIndex + 2);

            // When

    void testWriteBytesWireFormatWithDifferentBufferSizes(int bufferSize) {
        request = new Smb2QueryInfoRequest(mockConfig, testFileId);

        if (bufferSize > 0) {
            Encodable mockInputBuffer = mock(Encodable.class);
            when(mockInputBuffer.encode(any(byte[].class), anyInt())).thenReturn(bufferSize);
            when(mockInputBuffer.size()).thenReturn(bufferSize);

            try {

     *
     * @param sessionId unique identifier for the process session
     * @param cmdList list of command and arguments to execute
     * @param pbCall callback to configure the ProcessBuilder
     * @param bufferSize size of the buffer for process output
     * @param outputCallback callback to handle process output lines
     * @return JobProcess representing the started process

            return aggsList.get(index);
        }

        @Override
        public int size() {
            return aggsList.size();
        }
    }

    @Param({ "32", "512" })
    private int bufferSize;

    @Benchmark
    public SearchPhaseController.ReducedQueryPhase reduceAggs(TermsList candidateList) throws Exception {
        List<QuerySearchResult> shards = new ArrayList<>();

    }

    public PluginDescriptor build(ReaderSupplier readerSupplier, String source) throws PlexusConfigurationException {
        try (BufferedReader br = new BufferedReader(readerSupplier.open(), BUFFER_SIZE)) {
            br.mark(BUFFER_SIZE);
            XMLStreamReader xsr = XMLInputFactory.newFactory().createXMLStreamReader(br);
            xsr.nextTag();
            String nsUri = xsr.getNamespaceURI();