final List<E> delegate;
    final int delta;

    MisleadingSizeList(List<E> delegate, int delta) {
      this.delegate = delegate;
      this.delta = delta;
    }

    @Override
    protected List<E> delegate() {
      return delegate;
    }

    @Override
    public int size() {
      return delegate.size() + delta;
    }
  }

      }
    } else {
      count++;
      if (isFinite(value) && isFinite(mean)) {
        // Art of Computer Programming vol. 2, Knuth, 4.2.2, (15) and (16)
        double delta = value - mean;
        mean += delta / count;
        sumOfSquaresOfDeltas += delta * (value - mean);
      } else {
        mean = calculateNewMeanNonFinite(mean, value);
        sumOfSquaresOfDeltas = NaN;
      }
      min = Math.min(min, value);

         * handles any errors, and ensures cleanup operations are executed.
         * After successful crawling, it commits the index updates and
         * deletes old documents if configured to do so.
         */
        protected void process() {
            final DataStoreFactory dataStoreFactory = ComponentUtil.getDataStoreFactory();

  }

  @Test fun test() {
    val t1 = System.nanoTime() / 1e6

    val delays = mutableListOf(TimeUnit.MILLISECONDS.toNanos(1000), -1L)
    queue.schedule("task", TimeUnit.MILLISECONDS.toNanos(750)) {
      log.put("runOnce delays.size=${delays.size}")
      return@schedule delays.removeAt(0)
    }

    assertThat(log.take()).isEqualTo("runOnce delays.size=2")
    val t2 = System.nanoTime() / 1e6 - t1

   * size() as a hint only.
   *
   * @param delta the difference between the true size of the collection and the values returned by
   *     the size method
   */
  public static <T extends @Nullable Object> Collection<T> misleadingSizeCollection(int delta) {
    // It would be nice to be able to return a real concurrent

    }

    /**
     * Test multiple delay calls
     */
    public void test_multipleDelayCalls() {
        final TestIntervalController controller = new TestIntervalController();

        controller.delay(IntervalController.PRE_PROCESSING);
        controller.delay(IntervalController.POST_PROCESSING);
        controller.delay(IntervalController.NO_URL_IN_QUEUE);
        controller.delay(IntervalController.WAIT_NEW_URL);

     *
     * @return The number of query words.
     */
    public long getQueryWordsNum() {
        return suggester.getQueryWordsNum();
    }

    /**
     * Deletes all words from the suggest index.
     *
     * @return true if the operation was successful, false otherwise.
     */
    public boolean deleteAllWords() {

        controller.delayAfterProcessing();
        final long elapsed = (System.nanoTime() - start) / 1000000;

        assertTrue("No delay expected", elapsed < 50); // Should be nearly instant
    }

    /**
     * Test delayAfterProcessing with actual delay
     */
    public void test_delayAfterProcessing_withDelay() {
        final DefaultIntervalController controller = new DefaultIntervalController();

    /** Interval between requests in milliseconds */
    protected long requestInterval = 500;

    /**
     * Sends a list of documents to the search engine for indexing.
     * This method handles thumbnail processing, deletes old documents with the same URL,
     * and performs bulk indexing operations with proper error handling.
     *
     * @param searchEngineClient the search engine client to use for indexing

    }

    /**
     * Deletes suggest items by a query string.
     * @param queryString The query string.
     * @return The SuggestDeleteResponse.
     */
    public SuggestDeleteResponse deleteByQuery(final String queryString) {
        return deleteByQuery(QueryBuilders.queryStringQuery(queryString).defaultOperator(Operator.AND));
    }

    /**
     * Deletes suggest items by a query builder.