abstract ImmutableSortedSet<E> createDescendingSet();

  @Override
  public Spliterator<E> spliterator() {
    return new Spliterators.AbstractSpliterator<E>(
        size(), SPLITERATOR_CHARACTERISTICS | Spliterator.SIZED) {
      final UnmodifiableIterator<E> iterator = iterator();

      @Override
      public boolean tryAdvance(Consumer<? super E> action) {
        if (iterator.hasNext()) {

     * which are awaiting cleanup.
     */
    volatile int count;

    /**
     * Number of updates that alter the size of the table. This is used during bulk-read methods to
     * make sure they see a consistent snapshot: If modCounts change during a traversal of segments
     * computing size or checking containsValue, then we might have an inconsistent view of state so
     * (usually) must retry.
     */
    int modCount;

or

```sh
mc admin config set myminio/ api requests_max=1600
mc admin service restart myminio/
```

        });

        assertEquals(5, page1.size());

        // Get second page (5 items)
        final List<OpenSearchAccessResult> page2 = dataService.getAccessResultList(builder -> {
            builder.setQuery(QueryBuilders.termQuery("sessionId", sessionId));
            builder.setFrom(5);
            builder.setSize(5);
        });

        assertEquals(5, page2.size());

        dataService.delete(sessionId);

  @MapFeature.Require(SUPPORTS_REMOVE)
  public void testClear() {
    getMap().clear();
    assertTrue("After clear(), a map should be empty.", getMap().isEmpty());
    assertEquals(0, getMap().size());
    assertFalse(getMap().entrySet().iterator().hasNext());
  }

  @MapFeature.Require({FAILS_FAST_ON_CONCURRENT_MODIFICATION, SUPPORTS_REMOVE})
  @CollectionSize.Require(SEVERAL)

  }

  /**
   * Defer to {@link AbstractValueGraph#edges()} (based on {@link #successors(Object)}) for full
   * edges() implementation.
   */
  @Override
  protected long edgeCount() {
    return delegate().edges().size();
  }

  @Override
  public boolean isDirected() {
    return delegate().isDirected();
  }

  @Override
  public boolean allowsSelfLoops() {
    return delegate().allowsSelfLoops();
  }

        // Delete any remaining events beyond the search size limit (discard overflow)
        try {
            client.deleteByQuery(indexName, QueryBuilders.termQuery("hostname", hostname));
        } catch (final Exception e) {
            logger.debug("Failed to delete remaining log notifications.", e);
        }

        return "Sent log notifications: " + events.size() + " events.";
    }

    /**

        result.get(result.size() - 1).delegateString.hashCode());
    return result;
  }

  public void testResistsHashFloodingInConstruction() {
    CallsCounter smallCounter = new CallsCounter();
    List<CountsHashCodeAndEquals> haveSameHashesSmall = createAdversarialInput(10, smallCounter);
    int smallSize = haveSameHashesSmall.size();

    CallsCounter largeCounter = new CallsCounter();

                List<Object> c = (List<Object>) field.get(target);
                if (c == null) {
                    return;
                }

                for (int i = 0, size = c.size(); i < size; i++) {
                    Object value = c.get(i);

                    if (value != null) {
                        if (String.class == value.getClass()) {

        @DisplayName("Should reject offset+length exceeding buffer size in sign method")
        void testSignOffsetLengthExceedsBuffer() {
            byte[] data = new byte[100];
            assertThrows(IllegalArgumentException.class, () -> digest.sign(data, 50, 60, request, response),
                    "Should throw IllegalArgumentException when offset+length > buffer size");
        }

        @Test