return activeThreadCount.get();
    }

    /**
     * Increments the active thread count and returns the new value.
     * @return The incremented active thread count.
     */
    public int incrementAndGetActiveThreadCount() {
        return activeThreadCount.incrementAndGet();
    }

    /**
     * Decrements the active thread count and returns the new value.

      }
      runningTasks++;
    }
  }

  /** Decrements the running task count. */
  private void endTask() {
    synchronized (lock) {
      int numRunning = --runningTasks;
      if (numRunning == 0) {
        lock.notifyAll();
      }
    }
  }

    AtomicLong atomic = map.get(key);
    return atomic == null ? 0L : atomic.get();
  }

  /**
   * Increments by one the value currently associated with {@code key}, and returns the new value.
   */
  @CanIgnoreReturnValue
  public long incrementAndGet(K key) {
    return addAndGet(key, 1);
  }

  /**
   * Decrements by one the value currently associated with {@code key}, and returns the new value.
   */
  @CanIgnoreReturnValue

/**
 * A helper which does some thread-safe operations for aggregate futures, which must be implemented
 * differently in GWT. Namely:
 *
 * <ul>
 *   <li>Lazily initializes a set of seen exceptions
 *   <li>Decrements a counter atomically
 * </ul>
 */
@GwtCompatible
@ReflectionSupport(value = ReflectionSupport.Level.FULL)
abstract class AggregateFutureState<OutputT extends @Nullable Object>

        }

        /**
         * Increments the reference count for this statistics object.
         *
         * @return the new reference count after incrementing
         */
        public int increment() {
            return count.incrementAndGet();
        }

        /**
         * Decrements the reference count for this statistics object.
         *

    when (this[i]) {
      '\t', '\n', '\u000C', '\r', ' ' -> Unit
      else -> return i
    }
  }
  return endIndex
}

/**
 * Decrements [endIndex] until `input[endIndex - 1]` is not ASCII whitespace. Stops at [startIndex].
 */
internal fun String.indexOfLastNonAsciiWhitespace(
  startIndex: Int = 0,
  endIndex: Int = length,
): Int {
  for (i in endIndex - 1 downTo startIndex) {

        verify(tree, times(1)).release();
    }

    @Test
    @DisplayName("release() decrements usage; closes only when count reaches zero")
    void release_decrementsAndClosesOnZero() throws CIFSException {
        when(cfg.isTraceResourceUsage()).thenReturn(false);
        stubValidTree(8L, true, true);

        assertSame(response, out);
        verify(treeConnection).send(resourceLoc, request, response, params);
    }

    @Test
    @DisplayName("close calls release and decrements usage; double release throws")
    void closeAndReleaseBehavior() {
        // Validates usage counting and that an extra release() throws RuntimeCIFSException

     */
    protected boolean noWaitOnFolder = false;

    /**
     * Increments the active thread count using atomic operation.
     */
    protected void startCrawling() {
        crawlerContext.incrementAndGetActiveThreadCount();
    }

    /**
     * Decrements the active thread count using atomic operation.
     */
    protected void finishCrawling() {

func (l *LruList[K, V]) insertValue(k K, v V, expiresAt time.Time, at *Entry[K, V]) *Entry[K, V] {
	return l.insert(&Entry[K, V]{Value: v, Key: k, ExpiresAt: expiresAt}, at)
}

// Remove removes e from its list, decrements l.len
func (l *LruList[K, V]) Remove(e *Entry[K, V]) V {
	e.prev.next = e.next
	e.next.prev = e.prev
	e.next = nil // avoid memory leaks
	e.prev = nil // avoid memory leaks
	e.list = nil
	l.len--