@IgnoreJRERequirement
  public Stream<String> lines() throws IOException {
    BufferedReader reader = openBufferedStream();
    return reader.lines().onClose(() -> closeUnchecked(reader));
  }

  @IgnoreJRERequirement // helper for lines()
  /*
   * If we make these calls inline inside the lambda inside lines(), we get an Animal Sniffer error,

   *
   * {@snippet :
   * try (Stream<String> lines = source.lines()) {
   *   lines.map(...)
   *      .filter(...)
   *      .forEach(...);
   * }
   * }
   *
   * @throws IOException if an I/O error occurs while opening the stream
   * @since 22.0 (but only since 33.4.0 in the Android flavor)
   */
  @MustBeClosed
  public Stream<String> lines() throws IOException {

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

    public void test_run_maxBufferSizeConstant() {

        for (let line of this.lines) {
            line.style.visibility = 'visible'
        }
        this.start();
    }

    /**
     * Start the animation and rener the lines depending on their data attributes.
     */
    async start() {
        this.addFinish()
        await this._wait(this.startDelay);

        for (let line of this.lines) {
            const type = line.getAttribute(this.pfx);

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

    if (r instanceof Reader) {
      copyReaderToBuilder((Reader) r, sb);
    } else {
      copy(r, sb);
    }
    return sb;
  }

  /**
   * Reads all of the lines from a {@link Readable} object. The lines do not include
   * line-termination characters, but do include other leading and trailing whitespace.
   *
   * <p>Does not close the {@code Readable}. If reading files or resources you should use the {@link

        String result = scoreUpdater.execute();

        // Check format with class name, colon, count, and newline
        String[] lines = result.split("\n");
        assertEquals(2, lines.length);
        assertTrue(lines[0].matches("TestScoreBooster : \\d+"));
        assertTrue(lines[1].matches("TestScoreBooster : \\d+"));
    }

    // Test with null pointer exception
    public void test_execute_nullPointerException() {

import (
	"iter"
	"unicode"
	"unicode/utf8"
)

// Lines returns an iterator over the newline-terminated lines in the byte slice s.
// The lines yielded by the iterator include their terminating newlines.
// If s is empty, the iterator yields no lines at all.
// If s does not end in a newline, the final yielded line will not end in a newline.
// It returns a single-use iterator.
func Lines(s []byte) iter.Seq[[]byte] {

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

        /**
         * Constructor for InputStreamThread.

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