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

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

    }

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

            long id = 0;
            String line = null;
            while ((line = reader.readLine()) != null) {
                // Remove comments
                final String replacedLine = line.replaceAll("#.*$", StringUtil.EMPTY).trim();

                // Skip empty lines or comment lines
                if (replacedLine.length() == 0) {
                    if (updater != null) {

    private static Map<String, String> readProperties(Path file) throws IOException {
        Map<String, String> out = new LinkedHashMap<>();
        List<String> lines = Files.readAllLines(file, StandardCharsets.UTF_8);
        for (String line : lines) {
            String trimmed = line.trim();
            if (trimmed.isEmpty() || trimmed.startsWith("#") || trimmed.startsWith("!")) {
                continue;
            }

            long id = 0;
            String line = null;
            while ((line = reader.readLine()) != null) {
                // Remove comments
                final String replacedLine = line.replaceAll("#.*$", StringUtil.EMPTY).trim();

                // Skip empty lines or comment lines
                if (replacedLine.length() == 0) {
                    if (updater != null) {