}

var errUnreadByte = errors.New("bytes.Buffer: UnreadByte: previous operation was not a successful read")

// UnreadByte unreads the last byte returned by the most recent successful
// read operation that read at least one byte. If a write has happened since
// the last read, if the last read returned an error, or if the read read zero
// bytes, UnreadByte returns an error.
func (b *Buffer) UnreadByte() error {

        // Test user boost
        item.setUserBoost(2.0f);
        assertEquals(2.0f, item.getUserBoost(), 0.001f);

        // Test readings
        String[][] newReadings = { { "read1", "read2" }, { "read3" } };
        item.setReadings(newReadings);
        assertArrayEquals(newReadings, item.getReadings());

        // Test fields
        String[] fields = { "field1", "field2" };

		sparseMap = sparseMap[2:]
	}
	return spd, nil
}

// Read reads from the current file in the tar archive.
// It returns (0, io.EOF) when it reaches the end of that file,
// until [Next] is called to advance to the next file.
//
// If the current file is sparse, then the regions marked as a hole
// are read back as NUL-bytes.
//
// Calling Read on special types like [TypeLink], [TypeSymlink], [TypeChar],

			return n - remain, b.readErr()
		}
	}
}

// Read reads data into p.
// It returns the number of bytes read into p.
// The bytes are taken from at most one Read on the underlying [Reader],
// hence n may be less than len(p).
// To read exactly len(p) bytes, use io.ReadFull(b, p).
// If the underlying [Reader] can return a non-zero count with io.EOF,
// then this Read method can do so as well; see the [io.Reader] docs.

        return inputStream.read(b, off, len);
    }

    /**
     * Reads some number of bytes from the input stream and stores them into the buffer array b.
     *
     * @param b the buffer into which the data is read
     * @return the total number of bytes read into the buffer, or -1 if there is no more data
     * @throws IOException if an I/O error occurs
     */
    @Override
    public int read(final byte[] b) throws IOException {

     * This method delegates to {@link FileInputStream#mark(int)}.
     *
     * @param readlimit the maximum limit of bytes that can be read before the mark position becomes invalid
     */
    @Override
    public synchronized void mark(final int readlimit) {

	buf := make([]byte, 1)
	if _, err := b.Read(nil); err != nil {
		t.Fatalf("1st nil Read = %v; want nil", err)
	}
	if _, err := b.Read(buf); err != errFake {
		t.Fatalf("1st Read = %v; want errFake", err)
	}
	if _, err := b.Read(nil); err != nil {
		t.Fatalf("2nd nil Read = %v; want nil", err)
	}
	if _, err := b.Read(buf); err != nil {
		t.Fatalf("3rd Read with buffer = %v; want nil", err)
	}

/**
 * <p>
 * {@link ESSourceReader} reads documents from Elasticsearch using the scroll API.
 * It implements the {@link DocumentReader} interface to provide a way to iterate over documents
 * in a large index without loading all of them into memory at once.
 * </p>
 *
 * <p>
 * The reader supports limiting the number of documents read based on a percentage of the total documents

/**
 * The {@code QueryLogReader} interface provides methods to read query logs and close the reader.
 * It extends the {@code Closeable} interface, ensuring that resources can be released when no longer needed.
 */
public interface QueryLogReader extends Closeable {
    /**
     * Reads a query log.
     * @return The query log.
     */
    QueryLog read();

    @Override
    void close();

 */
public interface DocumentReader extends Closeable {
    /**
     * Reads a document and returns its contents as a map.
     *
     * @return a map containing the document's data, or null if there are no more documents to read.
     */
    Map<String, Object> read();

    @Override
    void close();