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 {

        assertArgumentNotNull("reader", reader);
        this.reader = reader;
    }

    @Override
    public boolean hasNext() {
        if (line == EMPTY) {
            line = ReaderUtil.readLine(reader);
        }
        return line != null;
    }

    @Override
    public String next() {
        if (!hasNext()) {
            throw new NoSuchElementException();
        }

        final int start = bufferIndex;

        fid = readInt2(buffer, bufferIndex);
        bufferIndex += 2;
        fileAttributes = readInt2(buffer, bufferIndex);
        bufferIndex += 2;
        lastWriteTime = readUTime(buffer, bufferIndex);
        bufferIndex += 4;
        dataSize = readInt4(buffer, bufferIndex);
        bufferIndex += 4;
        grantedAccess = readInt2(buffer, bufferIndex);
        bufferIndex += 2;

const (
	cgroupV1MemLimitFile = "/sys/fs/cgroup/memory/memory.limit_in_bytes"
	cgroupV2MemLimitFile = "/sys/fs/cgroup/memory.max"
)

func cgroupMemLimit() (limit uint64) {
	buf, err := os.ReadFile(cgroupV2MemLimitFile)
	if err != nil {
		buf, err = os.ReadFile(cgroupV1MemLimitFile)
	}
	if err != nil {
		return 0
	}
	limit, err = strconv.ParseUint(strings.TrimSpace(string(buf)), 10, 64)
	if err != nil {

 * <li> <code>TransactNamedPipe</code> A message-type pipe call that
 *      writes to and reads from an existing pipe descriptor in one operation.
 * <li> <code>CreateFile</code>, <code>ReadFile</code>,
 *      <code>WriteFile</code>, and <code>CloseFile</code> A byte-type pipe can
 *      be opened, written to, read from and closed using the standard Win32
 *      file operations.
 * </ul>
 *

  @Override
  float readFloat();

  @CanIgnoreReturnValue // to skip some bytes
  @Override
  double readDouble();

  @CanIgnoreReturnValue // to skip a line
  @Override
  @Nullable String readLine();

  @CanIgnoreReturnValue // to skip a field
  @Override
  String readUTF();

./mc replicate add myminio2/testbucket --remote-bucket http://minioadmin:minioadmin@localhost:9001/testbucket --priority 1

sleep 1

cp README.md internal.tar

./mc cp internal.tar myminio1/testbucket/dir/1.tar
./mc cp internal.tar myminio2/testbucket/dir/2.tar

sleep 1

./mc ls -r --versions myminio1/testbucket/dir/ >/tmp/dir_1.txt

    }

    @Test
    @DisplayName("readLine(): reads until newline and handles CRLF")
    void readLine_reads() throws Exception {
        SmbRandomAccessFile raf = spy(newInstance("r", false, false, false));
        // Sequence: 'a','b','\r','\n','c','\n'
        when(raf.read()).thenReturn((int) 'a', (int) 'b', (int) '\r', (int) '\n');
        assertEquals("ab", raf.readLine());

CHANGELOG/README.md...

 * <li><code>TransactNamedPipe</code> A message-type pipe call that
 * writes to and reads from an existing pipe descriptor in one operation.
 * <li><code>CreateFile</code>, <code>ReadFile</code>,
 * <code>WriteFile</code>, and <code>CloseFile</code> A byte-type pipe can
 * be opened, written to, read from and closed using the standard Win32
 * file operations.
 * </ul>
 *
 * <p>