/**
     * Delays after processing a URL.
     */
    @Override
    protected void delayAfterProcessing() {
        if (delayMillisAfterProcessing > 0) {
            ThreadUtil.sleep(delayMillisAfterProcessing);
        }
    }

    /**
     * Delays when no URL is in the queue.
     */
    @Override
    protected void delayAtNoUrlInQueue() {
        if (delayMillisAtNoUrlInQueue > 0) {

  public void testSize_populated() {
    for (LoadingCache<Object, Object> cache : caches()) {
      // don't let the entries get GCed
      List<Entry<Object, Object>> unused = warmUp(cache);
      assertEquals(WARMUP_SIZE, cache.size());
      assertMapSize(cache.asMap(), WARMUP_SIZE);
      checkValidState(cache);
    }
  }

  public void testContainsKey_found() {

 */
@GwtCompatible
@NullMarked
public class CountTest extends TestCase {
  public void testGet() {
    assertEquals(20, new Count(20).get());
  }

  public void testGetAndAdd() {
    Count holder = new Count(20);
    assertEquals(20, holder.get());
    holder.add(1);
    assertEquals(21, holder.get());
  }

  public void testAddAndGet() {
    Count holder = new Count(20);
    assertEquals(21, holder.addAndGet(1));

     *
     * @param crawlingInfo the crawling information entity to store
     * @throws FessSystemException if the crawling information is null
     */
    public void store(final CrawlingInfo crawlingInfo) {
        setupStoreCondition(crawlingInfo);

        crawlingInfoBhv.insertOrUpdate(crawlingInfo, op -> op.setRefreshPolicy(Constants.TRUE));

    }

    /**

            )
        .inOrder();
  }

  public void testLegacyAsyncDispatcher() {
    dispatcher = Dispatcher.legacyAsync();

    CyclicBarrier barrier = new CyclicBarrier(2);
    CountDownLatch latch = new CountDownLatch(2);

    new Thread(
            new Runnable() {
              @Override
              public void run() {
                try {
                  barrier.await();

     *
     * @param targetNodePath the target node path to set
     */
    public void setTargetNodePath(final String targetNodePath) {
        this.targetNodePath = targetNodePath;
    }

    /**
     * Sets the cache duration for XPathAPI instances.
     *
     * @param cacheDuration the cache duration in minutes
     */
    public void setCacheDuration(final long cacheDuration) {
        this.cacheDuration = cacheDuration;

     *
     * @param config the filter configuration containing initialization parameters
     * @throws ServletException if an error occurs during initialization
     */
    @Override
    public void init(final FilterConfig config) throws ServletException {
        servletContext = config.getServletContext();

        encoding = config.getInitParameter(LastaPrepareFilter.ENCODING_KEY);
        if (encoding == null) {

    //                                                                   =================
    @Override
    public void acceptPrimaryKeyMap(Entity entity, Map<String, ? extends Object> primaryKeyMap) {
    }

    @Override
    public void acceptAllColumnMap(Entity entity, Map<String, ? extends Object> allColumnMap) {
    }

    @Override

    }

    /**
     * Add an interface to the registry.
     *
     * @param name the interface name
     * @param syntax the interface syntax (UUID:version)
     */
    public static void addInterface(final String name, final String syntax) {
        INTERFACES.put(name, syntax);
    }

    String proto;
    String server;
    String endpoint = null;
    HashMap options = null;
    UUID uuid = null;

        lastEntry = pred;
      } else {
        succ.predecessorInValueSet = pred;
      }
    }

    private void deleteFromValueSet(ValueEntry<K, V> entry) {
      succeedsInValueSet(entry.predecessorInValueSet, entry.successorInValueSet);
    }

    private void appendToValueSet(ValueEntry<K, V> newEntry) {
      succeedsInValueSet(lastEntry, newEntry);
      lastEntry = newEntry;
    }