assertEquals(0, itemReadings.length);
    }

    @Test
    public void testToSuggestItemWithSingleReading() {
        // Test toSuggestItem with single reading
        String word = "single reading";
        float boost = 1.5f;
        List<String> readings = Arrays.asList("reading1");
        List<String> fields = Arrays.asList("field1");
        List<String> tags = Arrays.asList("tag1");

        "next() should still return first element after peeking", "A", peekingIterator.next());

    assertEquals("Should be able to peek() at middle element", "B", peekingIterator.peek());
    assertEquals(
        "Should be able to peek() middle element multiple times", "B", peekingIterator.peek());
    assertEquals(
        "next() should still return middle element after peeking", "B", peekingIterator.next());

	recursive    bool       `msg:"rec"`
	dataVersion  uint8      `msg:"v"`
}

func (m *metacache) finished() bool {
	return !m.ended.IsZero()
}

// worthKeeping indicates if the cache by itself is worth keeping.
func (m *metacache) worthKeeping() bool {
	if m == nil {
		return false
	}
	cache := m
	switch {
	case !cache.finished() && time.Since(cache.lastUpdate) > metacacheMaxRunningAge:

 * specific language governing permissions and limitations
 * under the License.
 */

/**
 * Provides an immutable XML processing API for Maven, offering classes and interfaces
 * for reading, manipulating, and writing XML documents in a thread-safe manner.
 * This package is used extensively for POM, settings, and other Maven configuration files.
 *
 * @since 4.0.0
 */

import java.io.EOFException;
import java.io.FilterInputStream;
import java.io.IOException;
import java.io.InputStream;

/**
 * An implementation of {@link DataInput} that uses little-endian byte ordering for reading {@code
 * short}, {@code int}, {@code float}, {@code double}, and {@code long} values.
 *
 * <p><b>Note:</b> This class intentionally violates the specification of its supertype {@code

                                    <tr>
                                        <th><la:message key="labels.elevate_word_reading"/></th>
                                        <td>${f:h(reading)}<la:hidden property="reading"/></td>
                                    </tr>
                                    <tr>
                                        <th><la:message key="labels.elevate_word_permissions"/></th>

     * @param type the target class type
     * @param stream the ASN.1 input stream
     * @return next object from stream cast to type
     * @throws PACDecodingException if types are incompatible
     * @throws IOException if reading from stream fails
     */
    public static <T extends ASN1Primitive> T as(final Class<T> type, final ASN1InputStream stream)
            throws PACDecodingException, IOException {
        return as(type, stream.readObject());

// license that can be found in the LICENSE file.

package lex

import (
	"text/scanner"

	"cmd/internal/src"
)

// A Stack is a stack of TokenReaders. As the top TokenReader hits EOF,
// it resumes reading the next one down.
type Stack struct {
	tr []TokenReader
}

// Push adds tr to the top (end) of the input stack. (Popping happens automatically.)
func (s *Stack) Push(tr TokenReader) {
	s.tr = append(s.tr, tr)
}

    private byte[] tmp = new byte[1];

    SmbFile file;

    private boolean largeReadX;

    private final boolean unsharedFile;

    private boolean smb2;

    /**
     * Creates an input stream for reading from the specified SMB URL
     *
     * @param url the SMB URL to read from
     * @param tc
     *            context to use
     * @throws SmbException if an SMB error occurs

import okio.ByteString
import okio.ByteString.Companion.decodeHex
import okio.FileSystem
import okio.Path
import okio.Path.Companion.toOkioPath
import okio.buffer
import okio.source

/**
 * Utilities for reading HPACK tests.
 */
object HpackJsonUtil {
  @Suppress("unused")
  private val MOSHI =
    Moshi
      .Builder()
      .add(
        object : Any() {