thread.start();
        thread.join(1000);

        String output = thread.getOutput();
        String[] lines = output.split("\n");

        assertTrue("Buffer should be limited to 10 items", lines.length <= 10);
        assertTrue("Last lines should be kept", output.contains("line15"));
    }

    @Test
    public void test_run_maxBufferSizeConstant() {

        assertTrue("Should have line4", thread.contains("line4"));
        assertTrue("Should have line5", thread.contains("line5"));
    }

    @Test
    public void test_emptyInputStream() throws IOException, InterruptedException {
        Process mockProcess = createMockProcess("");
        JobProcess jobProcess = new JobProcess(mockProcess);

        InputStreamThread thread = jobProcess.getInputStreamThread();

        String[] inputs = { "input" };
        CharMappingItem item = new CharMappingItem(1L, inputs, "output");

        // Test newline replacement in setNewOutput
        item.setNewOutput("line1\nline2\nline3");
        assertEquals("line1 line2 line3", item.getNewOutput());
    }

    @Test
    public void test_setNewOutput_withNull() {
        String[] inputs = { "input" };

        errorLogFile.useLines { lines ->
            lines.drop(startLine).forEach { line ->
                if (line.isBlank() || line.startsWith(">")) return@useLines
                val regex = Regex("""\s*(api|implementation)\(([^)]+)\)\s*""")
                regex.find(line)?.let {
                    dependencies.add(replaceProjectDependency(line.trim()))
                }
            }
        }

    private static final class Snippet {
        final int line;       // line of the [.multi-language-sample] header
        final Language lang;  // best-effort deduction (UNKNOWN allowed)

        Snippet(int line, Language lang) {
            this.line = line;
            this.lang = lang;
        }
    }

    private static final class Error {
        final int line;
        final String message;

            // Verify content structure
            boolean hasThreadLine = lines.stream().anyMatch(line -> line.startsWith("Thread:"));
            boolean hasStackTraceLine = lines.stream().anyMatch(line -> line.startsWith("\tat "));

            assertTrue("Should contain thread information", hasThreadLine);
            assertTrue("Should contain stack trace information", hasStackTraceLine);

        val lines = content.substring(startAfterIntro).lines()
        var pos = startAfterIntro
        var pastBlankLine = false
        for (line in lines) {
            if (pastBlankLine && !line.startsWith("- ") && line.isNotBlank()) {
                return pos
            }
            if (line.isNotBlank()) {
                pastBlankLine = true
            }

     * Captures output from command execution with configurable line buffering.
     */
    protected static class InputStreamThread extends Thread {

        /** Buffered reader for input stream. */
        private BufferedReader br;

        /** List to store captured output lines. */
        private final List<String> list = new LinkedList<>();

        /** Maximum number of lines to buffer. */
        private final int maxLineBuffer;

import org.apache.logging.log4j.Logger;

/**
 * A thread that reads from an input stream line by line and maintains a buffer of recent lines.
 * This class provides functionality to read input stream data asynchronously,
 * optionally process each line with a callback function, and maintain a circular buffer
 * of recent lines for retrieval.
 */
public class InputStreamThread extends Thread {
    /** Logger instance for this class */

    }

    private static String readWrapperVersion() throws IOException {
        Path props = Paths.get("gradle/wrapper/gradle-wrapper.properties");
        List<String> lines = Files.readAllLines(props, StandardCharsets.UTF_8);
        String distributionUrl =
            lines.stream()
                .map(String::trim)
                .filter(l -> !l.isEmpty() && !l.startsWith("#"))
                .filter(l -> l.startsWith("distributionUrl"))