final SystemHelper systemHelper = ComponentUtil.getSystemHelper();
        final long execTime = systemHelper.getCurrentTimeAsLong();
        if (logger.isDebugEnabled()) {
            logger.debug("Sending {} documents to a server.", docList.size());
        }
        try {
            if (fessConfig.isThumbnailCrawlerEnabled()) {
                final ThumbnailManager thumbnailManager = ComponentUtil.getThumbnailManager();

    LocalCache.logger.addHandler(logHandler);
  }

  @Override
  public void tearDown() throws Exception {
    super.tearDown();
    // TODO(cpovirk): run tests in other thread instead of messing with main thread interrupt status
    currentThread().interrupted();
    LocalCache.logger.removeHandler(logHandler);
  }

  private Throwable popLoggedThrowable() {

      int nextPermitsToAcquire = Math.max(1, random.nextInt(permits));
      permits -= nextPermitsToAcquire;
      rateLimiter.acquire(nextPermitsToAcquire);
    }
    rateLimiter.acquire(1); // to repay for any pending debt
    return NANOSECONDS.toMillis(stopwatch.instant - startTime);
  }

  private void assertEvents(String... events) {
    assertEquals(Arrays.toString(events), stopwatch.readEventsAndClear());
  }

      if (!seen.add(this)) {
        return null; // Already traversed this node.
      }
      ExampleStackTrace found = allowedPriorLocks.get(node);
      if (found != null) {
        return found; // Found a path ending at the node!
      }
      // Recurse the edges.
      for (Entry<LockGraphNode, ExampleStackTrace> entry : allowedPriorLocks.entrySet()) {
        LockGraphNode preAcquiredLock = entry.getKey();

   * size}, inclusive.
   *
   * @param start a user-supplied index identifying a starting position in an array, list or string
   * @param end a user-supplied index identifying an ending position in an array, list or string
   * @param size the size of that array, list or string
   * @throws IndexOutOfBoundsException if either index is negative or is greater than {@code size},

      assertThat(e).hasMessageThat().isEqualTo("Cannot get() on a pending future.");
    }
  }

  static void verifyTimedGetOnPendingFuture(Future<?> future) {
    try {
      future.get(0, SECONDS);
      fail();
    } catch (Exception e) {
      assertThat(e).isInstanceOf(IllegalStateException.class);
      assertThat(e).hasMessageThat().isEqualTo("Cannot get() on a pending future.");
    }
  }

    }

    protected abstract String doBuildColumnString(String dm);

    @Override
    public String toStringWithRelation() { // #pending
        return toString();
    }

    @Override
    public String buildDisplayString(String name, boolean column, boolean relation) { // #pending
        return toString();
    }

    // ===================================================================================

    public static final int SMB2_DIALECT_ANY = 0x02FF;

    /**
     * 
     */
    public static final int SMB2_GLOBAL_CAP_DFS = 0x1;

    /**
     * 
     */
    public static final int SMB2_GLOBAL_CAP_LEASING = 0x2;

    /**
     * 
     */
    public static final int SMB2_GLOBAL_CAP_LARGE_MTU = 0x4;

    /**
     * 
     */
    public static final int SMB2_GLOBAL_CAP_MULTI_CHANNEL = 0x8;

    /**

import static com.google.common.base.Preconditions.checkState;
import static com.google.common.graph.GraphConstants.PARALLEL_EDGES_NOT_ALLOWED;
import static com.google.common.graph.GraphConstants.REUSING_EDGE;
import static com.google.common.graph.GraphConstants.SELF_LOOPS_NOT_ALLOWED;
import static java.util.Objects.requireNonNull;

import com.google.common.collect.ImmutableList;

        return facadeSelectList(createCB(cbLambda));
    }

    public PagingResultBean<CrawlingInfoParam> selectPage(CBCall<CrawlingInfoParamCB> cbLambda) {
        // #pending same?
        return (PagingResultBean<CrawlingInfoParam>) facadeSelectList(createCB(cbLambda));
    }

    public void selectCursor(CBCall<CrawlingInfoParamCB> cbLambda, EntityRowHandler<CrawlingInfoParam> entityLambda) {