assertEquals(expectedMessage, lookupMessage(code).orElse(null));
    }

    @ParameterizedTest
    @ValueSource(ints = { -1, Integer.MIN_VALUE, Integer.MAX_VALUE })
    @DisplayName("Unknown codes: lookup returns empty Optional")
    void lookup_returns_empty_for_unknown_codes(int unknownCode) {
        // Invalid inputs: codes not present should yield no message

        reader = new ESSourceReader(client, settings, indexName);
        reader.setScrollSize(1000);
        reader.addSort(SortBuilders.fieldSort("field2").order(SortOrder.DESC));
        count = 0;
        prev = Integer.MAX_VALUE;
        while ((source = reader.read()) != null) {
            int current = Integer.parseInt(source.get("field2").toString());
            assertTrue(prev > current);
            prev = current;
            count++;

  /** Counts the bytes in the given input stream using skip if possible. */
  private long countBySkipping(InputStream in) throws IOException {
    long count = 0;
    long skipped;
    while ((skipped = skipUpTo(in, Integer.MAX_VALUE)) > 0) {
      count += skipped;
    }
    return count;
  }

  /**
   * Copies the contents of this byte source to the given {@code OutputStream}. Does not close
   * {@code output}.
   *

  }

  public void testTryFind() {
    Iterable<String> list = newArrayList("cool", "pants");
    assertThat(tryFind(list, equalTo("cool"))).hasValue("cool");
    assertThat(tryFind(list, equalTo("pants"))).hasValue("pants");
    assertThat(tryFind(list, Predicates.alwaysTrue())).hasValue("cool");
    assertThat(tryFind(list, Predicates.alwaysFalse())).isAbsent();
    assertCanIterateAgain(list);
  }

  }

  public void testGreaterThan() {
    Range<Integer> range = Range.greaterThan(5);
    assertFalse(range.contains(5));
    assertTrue(range.contains(6));
    assertTrue(range.contains(Integer.MAX_VALUE));
    assertTrue(range.hasLowerBound());
    assertEquals(5, (int) range.lowerEndpoint());
    assertEquals(OPEN, range.lowerBoundType());
    assertUnboundedAbove(range);
    assertFalse(range.isEmpty());

    }

    // Test getTimeAdjustTimeMillisAsLong values
    public void test_getTimeAdjustTimeMillisAsLong_values() {
        Long[] testValues = { 0L, 1L, -1L, 1000L, -1000L, 60000L, -60000L, 3600000L, -3600000L, Long.MAX_VALUE, Long.MIN_VALUE };

        for (Long value : testValues) {
            FessConfig testConfig = new FessConfig.SimpleImpl() {
                private static final long serialVersionUID = 1L;

        assertEquals(nameBytes.length, SMBUtil.readInt4(buffer, 8));
    }

    @ParameterizedTest
    @DisplayName("Test with various timeout values")
    @ValueSource(longs = { 0L, 1L, -1L, Long.MAX_VALUE, Long.MIN_VALUE, 1000L, -1000L })
    void testWithVariousTimeoutValues(long timeout) {
        // Setup
        String pipeName = "TestPipe";

  var trailers: Headers
    get() = trailersBuilder.build()
    set(value) {
      this.trailersBuilder = value.newBuilder()
    }

  private var body: Buffer? = null

  var throttleBytesPerPeriod: Long = Long.MAX_VALUE
    private set
  private var throttlePeriodAmount = 1L
  private var throttlePeriodUnit = TimeUnit.SECONDS

  @set:JvmName("socketPolicy")
  var socketPolicy: SocketPolicy = SocketPolicy.KEEP_OPEN

  }

  // cloned from ImmutableCollection
  private static int expandedCapacity(int oldCapacity, int minCapacity) {
    if (minCapacity < 0) {
      throw new IllegalArgumentException("cannot store more than Integer.MAX_VALUE elements");
    } else if (minCapacity <= oldCapacity) {
      return oldCapacity;
    }
    // careful of overflow!
    int newCapacity = oldCapacity + (oldCapacity >> 1) + 1;
    if (newCapacity < minCapacity) {

      @SuppressWarnings("unchecked")
      K castKey = (K) key;
      @SuppressWarnings("unchecked") // similar to the above
      V castValue = (V) value;

      alertListenerIfPresent(castKey, castValue, RemovalCause.EXPLICIT);
      remove(key);
      return true;
    }
    return false;
  }

  @Override
  public boolean replace(K key, V oldValue, V newValue) {