assertThrows(IllegalArgumentException.class, () -> intermediate.indexes(1, 11, 3));
  }

  public void testScale_indexes_collection_negative() {
    Quantiles.Scale intermediate = Quantiles.scale(10);
    assertThrows(
        IllegalArgumentException.class, () -> intermediate.indexes(ImmutableList.of(1, -1, 3)));
  }

  public void testScale_indexes_collection_tooHigh() {

    assertThrows(IllegalArgumentException.class, () -> intermediate.indexes(1, 11, 3));
  }

  public void testScale_indexes_collection_negative() {
    Quantiles.Scale intermediate = Quantiles.scale(10);
    assertThrows(
        IllegalArgumentException.class, () -> intermediate.indexes(ImmutableList.of(1, -1, 3)));
  }

  public void testScale_indexes_collection_tooHigh() {

          private boolean called = false;

          @Override
          public void onSuccess(String result) {
            fail("Was not expecting onSuccess() to be called.");
          }

          @Override
          public void onFailure(Throwable t) {
            synchronized (monitor) {
              assertFalse(called);
              assertThat(t).isInstanceOf(CancellationException.class);

        assertNotNull(job);
    }

    public void test_execute_success() {
        // Execute the job
        String result = purgeDocJob.execute();

        // Assert deleteByQuery was called
        assertTrue(deleteByQueryCalled);

        // Assert correct index was used
        assertEquals("fess.update", deleteIndex);

        // Assert query builder is correct
        assertNotNull(deleteQuery);

   * <p>This method should return promptly; prefer to do work on a different thread where it is
   * convenient. It is invoked exactly once on service shutdown, even when {@link #stopAsync} is
   * called multiple times.
   *
   * <p>If {@link #stopAsync} is called on a {@link State#STARTING} service, this method is not
   * invoked immediately. Instead, it will be deferred until after the service is {@link

     * caught above) can linger and affect listeners.
     */
  }

  /**
   * Called before runInterruptibly - if true, runInterruptibly and afterRanInterruptibly will not
   * be called.
   */
  abstract boolean isDone();

  /**
   * Do interruptible work here - do not complete Futures here, as their listeners could be
   * interrupted.

    }
  }

  private fun logEvent(e: ConnectionEvent) {
    if (e.connection != null) {
      assertThat(Thread.holdsLock(e.connection), "Called with lock $${e.connection}")
        .isFalse()
    }
    for (lock in forbiddenLocks) {
      assertThat(Thread.holdsLock(lock), "Called with lock $lock")
        .isFalse()
    }

    if (enforceOrder) {
      checkForStartEvent(e)
    }

            }
        };
        ComponentUtil.register(factory, "webApiManagerFactory");

        // Execute
        webApiFilter.doFilter(request, response, chain);

        // Verify manager was called and chain was not called directly
        assertTrue(managerCalled.get());
        assertFalse(chainCalled.get());
    }

    // Test doFilter with ServletRequest and ServletResponse (not HTTP variants)

        // Verify that the super constructor was called with the correct arguments
        // Note: Mockito cannot directly verify super constructor calls.
        // We assume if the object is created, the super constructor was called.
        // We can verify the state of the object after construction.

        // Verify ptype and flags are set correctly

        scriptExecutor.addShutdownListener(listener);

        // Verify listener not called yet
        assertFalse(listener.wasShutdownCalled());

        // Call shutdown
        scriptExecutor.shutdown();

        // Verify listener was called
        assertTrue(listener.wasShutdownCalled());
    }

    public void test_shutdown_withoutListener() {