return this;
    }

    public void setState_Equal(String state) {
        setState_Term(state, null);
    }

    public void setState_Equal(String state, ConditionOptionCall<TermQueryBuilder> opLambda) {
        setState_Term(state, opLambda);
    }

    public void setState_Term(String state) {
        setState_Term(state, null);
    }

    assertTrue(future.isDone());
    assertListenerRunImmediately(future);
    assertEquals(1, threadLocalCount.get().intValue());
    otherThread.join(1000);
    assertEquals(Thread.State.TERMINATED, otherThread.getState());
    Throwable throwable = throwableFromOtherThread.get();
    assertNull(
        "Throwable from other thread: "
            + (throwable == null ? null : Throwables.getStackTraceAsString(throwable)),

                        .forEach(v -> modifyDeleteEntry(modifyList, attrInternationaliSDNNumber, v)));
        final String attrState = fessConfig.getLdapAttrState();
        OptionalUtil.ofNullable(user.getState()).filter(StringUtil::isNotBlank).ifPresent(s -> modifyReplaceEntry(modifyList, attrState, s))
                .orElse(() -> getAttributeValueList(result, attrState).stream().forEach(v -> modifyDeleteEntry(modifyList, attrState, v)));

    final long timeout = TimeUnit.SECONDS.toNanos(60);

    final Supplier<Boolean> supplier =
        new Supplier<Boolean>() {
          boolean isWaiting(Thread thread) {
            switch (thread.getState()) {
              case BLOCKED:
              case WAITING:
              case TIMED_WAITING:
                return true;
              default:
                return false;
            }
          }

    final long timeout = TimeUnit.SECONDS.toNanos(60);

    final Supplier<Boolean> supplier =
        new Supplier<Boolean>() {
          boolean isWaiting(Thread thread) {
            switch (thread.getState()) {
              case BLOCKED:
              case WAITING:
              case TIMED_WAITING:
                return true;
              default:
                return false;
            }
          }

                .setScopes(Arrays.asList(getOicScope()))//
                .setResponseTypes(Arrays.asList("code"))//
                .setRedirectUri(getOicRedirectUrl())//
                .setState(state)//
                .build();
    }

    protected LoginCredential processCallback(final HttpServletRequest request, final String code) {
        try {
            final TokenResponse tr = getTokenUrl(code);

   * state: BLOCKED, WAITING, or TIMED_WAITING.
   */
  void waitForThreadToEnterWaitState(Thread thread, long timeoutMillis) {
    long startTime = System.nanoTime();
    for (; ; ) {
      Thread.State s = thread.getState();
      if (s == Thread.State.BLOCKED || s == Thread.State.WAITING || s == Thread.State.TIMED_WAITING)
        return;
      else if (s == Thread.State.TERMINATED) fail("Unexpected thread termination");

      // we want to wait until each thread is WAITING - one thread waiting inside CacheLoader.load
      // (in startSignal.await()), and the others waiting for that thread's result.
      while (thread.isAlive() && thread.getState() != Thread.State.WAITING) {
        Thread.yield();
      }
    }
    gettersStartedSignal.countDown();
    gettersComplete.await();

        }
    }

    public void setState_Terms() {
        setState_Terms(null);
    }

    public void setState_Terms(ConditionOptionCall<TermsAggregationBuilder> opLambda) {
        setState_Terms("state", opLambda, null);
    }

    public void setState_Terms(ConditionOptionCall<TermsAggregationBuilder> opLambda, OperatorCall<BsUserCA> aggsLambda) {
        setState_Terms("state", opLambda, aggsLambda);
    }

    assertEquals(THREAD_PRIORITY, thread.getPriority());
    assertEquals(THREAD_DAEMON, thread.isDaemon());
    assertSame(UNCAUGHT_EXCEPTION_HANDLER, thread.getUncaughtExceptionHandler());
    assertSame(Thread.State.NEW, thread.getState());

    assertFalse(completed);
    thread.start();
    thread.join();
    assertTrue(completed);
  }

  public void testNulls() {
    NullPointerTester npTester = new NullPointerTester();