}

    @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());

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

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

		}
	}

	{
		buf := make([]byte, 5)
		// Test for negative offset.
		if _, err = xlStorage.ReadFile(t.Context(), volume, "myobject", -1, buf, v); err == nil {
			t.Fatalf("expected: error, got: <nil>")
		}
	}

	for range 2 {
		// Following block validates all ReadFile test cases.
		for i, testCase := range testCases {
			var n int64
			// Common read buffer.

  @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();

        bufferIndex += 4;
        server.sessionKey = readInt4(buffer, bufferIndex);
        bufferIndex += 4;
        server.capabilities = readInt4(buffer, bufferIndex);
        bufferIndex += 4;
        server.serverTime = readTime(buffer, bufferIndex);
        bufferIndex += 8;
        server.serverTimeZone = readInt2(buffer, bufferIndex);
        bufferIndex += 2;
        server.encryptionKeyLength = buffer[bufferIndex++] & 0xFF;

				meta.name = decodeDirObject(meta.name)

				return send(meta)
			}
			// Check legacy.
			if HasSuffix(entry, xlStorageFormatFileV1) && legacy {
				var meta metaCacheEntry
				meta.metadata, err = xioutil.ReadFile(pathJoinBuf(sb, volumeDir, current, entry))
				diskHealthCheckOK(ctx, err)
				if err != nil {
					if !IsErrIgnored(err, io.EOF, io.ErrUnexpectedEOF) {
						internalLogIf(ctx, err)
					}
					continue

        // Verify time was read correctly (accounting for UTime conversion)
        long readTime = (Long) getFieldValue(response, "lastWriteTime");
        // UTime is seconds since 1970, so we need to compare at second precision
        assertEquals(lastWriteTime / 1000, readTime / 1000);
    }

    @Test
    void testReadParameterWordsWireFormatWithZeroWordCount() {

        } else {
          System.err.println(callback.prompt)
          callback.password =
            System.`in`
              .bufferedReader()
              .readLine()
              .toCharArray()
        }
      } else {
        throw UnsupportedCallbackException(callback)
      }
    }
  }
}

fun main() {
  YubikeyClientAuth().run()

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