}
        return (T) field;
    }

    /**
     * Iterates through all access results for a session, calling the callback for each result.
     * Uses OpenSearch scroll API for efficient iteration over large result sets.
     *
     * @param sessionId The session ID.
     * @param callback The callback to execute for each access result.
     */
    @Override

   * range [0, k) and ignore the remaining elements.
   */
  private final @Nullable T[] buffer;
  private int bufferSize;

  /**
   * The largest of the lowest k elements we've seen so far relative to this comparator. If
   * bufferSize ≥ k, then we can ignore any elements greater than this value.
   */
  private @Nullable T threshold;

        final IllegalStateException iseCause = new IllegalStateException("Invalid parser state");
        final OutOfMemoryError oomCause = new OutOfMemoryError("Query too large");

        // Execute
        final InvalidQueryException npeException = new InvalidQueryException(messageCode, message, npeCause);

                return props;
            }
        };
        assertEquals(Long.valueOf(-86400000), negativeEnv.getTimeAdjustTimeMillisAsLong());

        // Test large value (one year as mentioned in comment)
        FessEnv.SimpleImpl yearEnv = new FessEnv.SimpleImpl() {
            protected Properties prepareProperties() {
                Properties props = new Properties();

  try {
    toLong()
  } catch (_: NumberFormatException) {
    defaultValue
  }

/**
 * Returns this as a non-negative integer, or 0 if it is negative, or [Int.MAX_VALUE] if it is too
 * large, or [defaultValue] if it cannot be parsed.
 */
internal fun String?.toNonNegativeInt(defaultValue: Int): Int {
  try {
    val value = this?.toLong() ?: return defaultValue
    return when {

    val newLimit = if (header.length != -1L) byteCount + header.length else -1L
    if (pushedLimit != -1L && newLimit > pushedLimit) {
      throw ProtocolException("enclosed object too large")
    }

    limit = newLimit
    constructed = header.constructed
    if (name != null) path += name
    try {
      val result = block(header)

      // The object processed bytes beyond its range.

         * than a handful of exceptions. But it seems prudent to set a cap on how many we'll cache.
         * This avoids out-of-control memory consumption, and it keeps the cache from growing so
         * large that doing the lookup is noticeably slower than redoing the work would be.
         *
         * Ideally we'd have a real eviction policy, but until we see a problem in practice, I hope

  private enum Timeout {
    MIN(Long.MIN_VALUE, "-oo"),
    MINUS_SMALL(-SMALL_TIMEOUT_MILLIS, "-" + SMALL_TIMEOUT_MILLIS + "ms"),
    ZERO(0L, "0ms"),
    SMALL(SMALL_TIMEOUT_MILLIS, SMALL_TIMEOUT_MILLIS + "ms"),
    LARGE(UNEXPECTED_HANG_DELAY_MILLIS * 2, (2 * UNEXPECTED_HANG_DELAY_MILLIS) + "ms"),
    MAX(Long.MAX_VALUE, "+oo");

    final long millis;
    final String label;

    Timeout(long millis, String label) {

		{name: "small", data: []byte("hello, world!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!")},
		{name: "large", data: bytes.Repeat([]byte("hello, world"), 1000000), wantIdx: true},
	}

	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			buf := make([]byte, 100) // make small buffer to ensure multiple reads are required for large case

			r, idxCB := newS2CompressReader(bytes.NewReader(tt.data), int64(len(tt.data)), false)

   * response body. Call `body.source().request(1024 * 1024)` to block until either that's done, or
   * 1 MiB of response data is loaded into memory. (You could use any size here, though large values
   * risk exhausting memory.)
   *
   * This returns an empty value if the trailers are available, but have no data.
   *