/** Read a single line counted against the header size limit. */
  fun readLine(): String {
    val line = source.readUtf8LineStrict(headerLimit)
    headerLimit -= line.length.toLong()
    return line
  }

  /** Reads headers or trailers. */
  fun readHeaders(): Headers {
    val result = Headers.Builder()
    while (true) {
      val line = readLine()
      if (line.isEmpty()) break
      result.addLenient(line)
    }

      return reader.readLine();
    } catch (Throwable e) {
      throw closer.rethrow(e);
    } finally {
      closer.close();
    }
  }

  /**
   * Reads all the lines of this source as a list of strings. The returned list will be empty if
   * this source is empty.
   *
   * <p>Like {@link BufferedReader#readLine()}, this method considers a line to be a sequence of

            String line = br.readLine();
            while (line != null) {
                lineNumber++;
                gatherDeadUserGuideLinksInLineReleaseNotes(sourceFile, line, lineNumber, errorsForFile);
                gatherDeadJavadocLinksInLineReleaseNotes(sourceFile, line, lineNumber, errorsForFile);

                line = br.readLine();
            }
        } catch (IOException e) {

    DataInput in = new LittleEndianDataInputStream(new ByteArrayInputStream(data));
    UnsupportedOperationException expected =
        assertThrows(UnsupportedOperationException.class, in::readLine);
    assertThat(expected).hasMessageThat().isEqualTo("readLine is not supported");
  }

  public void testReadLittleEndian() throws IOException {
    DataInput in = new LittleEndianDataInputStream(new ByteArrayInputStream(data));

// of the line. The returned buffer is only valid until the next call to
// ReadLine. ReadLine either returns a non-nil line or it returns an error,
// never both.
//
// The text returned from ReadLine does not include the line end ("\r\n" or "\n").
// No indication or error is given if the input ends without a final line end.
// Calling [Reader.UnreadByte] after ReadLine will always unread the last byte read

    BufferedReader r = new BufferedReader(getChunkedReader(input, chunk));
    List<String> lines = new ArrayList<>();
    String line;
    while ((line = r.readLine()) != null) {
      lines.add(line);
    }
    r.close();
    return lines;
  }

  private static List<String> readUsingReader(String input, int chunk, boolean asReader)
      throws IOException {

        ByteStreams.newDataInput(
            "This is a line\r\nThis too\rand this\nand also this".getBytes(UTF_8));
    assertThat(in.readLine()).isEqualTo("This is a line");
    assertThat(in.readLine()).isEqualTo("This too");
    assertThat(in.readLine()).isEqualTo("and this");
    assertThat(in.readLine()).isEqualTo("and also this");
  }

  public void testNewDataInput_readFloat() {

        ByteStreams.newDataInput(
            "This is a line\r\nThis too\rand this\nand also this".getBytes(UTF_8));
    assertThat(in.readLine()).isEqualTo("This is a line");
    assertThat(in.readLine()).isEqualTo("This too");
    assertThat(in.readLine()).isEqualTo("and this");
    assertThat(in.readLine()).isEqualTo("and also this");
  }

  public void testNewDataInput_readFloat() {

	if !ok || failed {
		t.Errorf("asm: %s assembly failed", goarch)
		return
	}
	output := strings.Split(testOut.String(), "\n")

	// Reconstruct expected output by independently "parsing" the input.
	data, err := os.ReadFile(input)
	if err != nil {
		t.Error(err)
		return
	}
	lineno := 0
	seq := 0
	hexByLine := map[string]string{}
	lines := strings.SplitAfter(string(data), "\n")
Diff:
	for _, line := range lines {

			f, err := os.Create(goldenFile)
			if err != nil {
				t.Fatal(err)
			}
			for _, feat := range w.Features() {
				fmt.Fprintf(f, "%s\n", feat)
			}
			f.Close()
		}

		bs, err := os.ReadFile(goldenFile)
		if err != nil {
			t.Fatalf("opening golden.txt for package %q: %v", fi.Name(), err)
		}
		wanted := strings.Split(string(bs), "\n")
		slices.Sort(wanted)
		for _, feature := range wanted {