thread.join(1000);

        assertEquals("All lines should be processed", 5000, receivedLines.size());
        assertEquals("First line", "Line number 0", receivedLines.get(0));
        assertEquals("Last line", "Line number 4999", receivedLines.get(4999));
    }

    @Test
    public void test_run_concurrentAccess() throws InterruptedException {
        String input = "concurrent1\nconcurrent2\nconcurrent3";

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

        assertEquals("return 1 + 2", activityHelper.normalizeScript("return 1 + 2"));
    }

    @Test
    public void test_normalizeScript_withControlCharacters() {
        assertEquals("line1 line2 line3", activityHelper.normalizeScript("line1\nline2\rline3"));
        assertEquals("tab1_tab2", activityHelper.normalizeScript("tab1\ttab2"));
        // \t -> _, \n -> space, \r -> space, \n -> space

def extract_code_includes(lines: list[str]) -> list[CodeIncludeInfo]:
    """
    Extract lines that contain code includes.

    Return list of CodeIncludeInfo, where each dict contains:
    - `line_no` - line number (1-based)
    - `line` - text of the line
    """

    includes: list[CodeIncludeInfo] = []
    for line_no, line in enumerate(lines, start=1):
        if CODE_INCLUDE_RE.match(line):

 * <p>Several methods in this class, such as {@link #readLines()}, break the contents of the source
 * into lines. Like {@link BufferedReader}, these methods break lines on any of {@code \n}, {@code
 * \r} or {@code \r\n}, do not include the line separator in each line and do not consider there to
 * be an empty line at the end if the contents are terminated with a line separator.
 *

                }
                valueLines.add(line);
                while (!line.isEmpty() && contains(WHITE_SPACE, line.charAt(0))) {
                    line = line.substring(1, line.length());
                }
                buffer.append(line);
                if (!combine) {
                    break;
                }
            }
            return buffer.toString();

                }
                valueLines.add(line);
                while (!line.isEmpty() && contains(WHITE_SPACE, line.charAt(0))) {
                    line = line.substring(1, line.length());
                }
                buffer.append(line);
                if (!combine) {
                    break;
                }
            }
            return buffer.toString();

    TestCharSource lines = new TestCharSource(LINES);
    assertThat(lines.readFirstLine()).isEqualTo("foo");
    assertTrue(lines.wasStreamOpened() && lines.wasStreamClosed());
  }

  public void testReadLines_toList() throws IOException {
    TestCharSource lines = new TestCharSource(LINES);
    assertEquals(ImmutableList.of("foo", "bar", "baz", "something"), lines.readLines());

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

	seq := 0
	hexByLine := map[string]string{}
	lines := strings.SplitAfter(string(data), "\n")
Diff:
	for _, line := range lines {
		lineno++

		// Ignore include of textflag.h.
		if strings.HasPrefix(line, "#include ") {
			continue
		}

		// Ignore GLOBL.
		if strings.HasPrefix(line, "GLOBL ") {
			continue
		}

		// The general form of a test input line is:
		//	// comment