return list.get(index);
    }

    private ChannelInfo selectLeastLoaded(Collection<ChannelInfo> channels) {
        ChannelInfo leastLoadedChannel = null;
        long minPending = Long.MAX_VALUE;
        for (ChannelInfo channel : channels) {
            long pending = channel.getRequestsPending();
            if (pending < minPending) {
                minPending = pending;

        public InternalAggregation.ReduceContext forFinalReduction() {
            final MultiBucketConsumerService.MultiBucketConsumer bucketConsumer = new MultiBucketConsumerService.MultiBucketConsumer(
                Integer.MAX_VALUE,
                new NoneCircuitBreakerService().getBreaker(CircuitBreaker.REQUEST)
            );

    checkPositionIndexes(fromIndex, toIndex, array.length);
    for (int i = fromIndex; i < toIndex; i++) {
      array[i] ^= Integer.MAX_VALUE;
    }
    Arrays.sort(array, fromIndex, toIndex);
    for (int i = fromIndex; i < toIndex; i++) {
      array[i] ^= Integer.MAX_VALUE;
    }
  }

  /**
   * Returns dividend / divisor, where the dividend and divisor are treated as unsigned 32-bit
   * quantities.

    CountDownLatch submitSuccessful = new CountDownLatch(1);
    ExecutorService executorService =
        new ThreadPoolExecutor(
            0,
            Integer.MAX_VALUE,
            60L,
            SECONDS,
            new SynchronousQueue<Runnable>(),
            new ThreadFactoryBuilder().setDaemon(true).build()) {
          @Override

    }

    @Test
    @DisplayName("Test with maximum values")
    void testWithMaximumValues() {
        trans2FindFirst2 = new Trans2FindFirst2(mockConfig, "\\test", "*.*", 0xFFFF, 65535, Integer.MAX_VALUE);

        byte[] buffer = new byte[256];
        int written = trans2FindFirst2.writeParametersWireFormat(buffer, 0);

        // Verify search attributes are still masked

    @Test
    public void testThresholdWithLargeValue() {
        CurlRequest request = new CurlRequest(Method.GET, "https://example.com");

        // Large threshold value
        int largeThreshold = Integer.MAX_VALUE;
        request.threshold(largeThreshold);

        assertEquals(largeThreshold, request.threshold());
    }

    @Test
    public void testBodyWithUnicodeCharacters() {

    IllegalArgumentException expected =
        assertThrows(
            IllegalArgumentException.class,
            () -> builder.addAll(nCopies(Integer.MAX_VALUE - 50, "a")));
    assertThat(expected)
        .hasMessageThat()
        .contains("cannot store more than Integer.MAX_VALUE elements");
  }

  }

  // 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) {

        if (rows == Integer.MIN_VALUE) {
            return scrollDown(Integer.MAX_VALUE);
        }
        return rows > 0 ? appendEscapeSequence('S', rows) : rows < 0 ? scrollDown(-rows) : this;
    }

    public Ansi scrollDown(final int rows) {
        if (rows == Integer.MIN_VALUE) {
            return scrollUp(Integer.MAX_VALUE);
        }

      super(key, hash, next);
    }

    // The code below is exactly the same for each access entry type.

    volatile long accessTime = Long.MAX_VALUE;

    @Override
    public long getAccessTime() {
      return accessTime;
    }

    @Override
    public void setAccessTime(long time) {
      this.accessTime = time;
    }