private static Boolean isSnapshotBuild;
    private static Provider<BwcVersions> bwcVersions;

    /**
     * Initialize global build parameters. This method accepts and a initialization function which in turn accepts a
     * {@link MutableBuildParams}. Initialization can be done in "stages", therefore changes override existing values, and values from

        final String name = fe.getName();
        if (this.nameFilter == null) {
            return true;
        }
        try {
            if (!this.nameFilter.accept(this.parent, name)) {
                return false;
            }
            return true;
        } catch (final CIFSException e) {
            log.error("Failed to apply name filter", e);
            return false;

        String name, BiConsumer<T, Object> queryLambda, IntToDoubleFunction asymptotic) {
      return new QueryOp<T>() {
        @Override
        void apply(T collection, Object query) {
          queryLambda.accept(collection, query);
        }

        @Override
        double expectedAsymptotic(int n) {
          return asymptotic.applyAsDouble(n);
        }

        @Override

  }

  @Override
  public void forEachEntry(ObjIntConsumer<? super E> action) {
    checkNotNull(action);
    for (int i = 0; i < enumConstants.length; i++) {
      if (counts[i] > 0) {
        action.accept(enumConstants[i], counts[i]);
      }
    }
  }

  @Override
  public Iterator<E> iterator() {
    return Multisets.iteratorImpl(this);
  }

  @GwtIncompatible // java.io.ObjectOutputStream

   * @Nullable X>, then users might pass a TypeParameter<Y>, where Y is a subtype of X, while still
   * passing a TypeToken<X>. This would be invalid. Maybe we could accept a TypeParameter<@PolyNull
   * X> if we support such a thing? It would be weird or misleading for users to be able to pass
   * `new TypeParameter<@Nullable T>() {}` and have it act as a plain `TypeParameter<T>`, but

      Map<K, V> delegate = delegateOrNull();
      if (delegate != null) {
        delegate.keySet().forEach(action);
      } else {
        for (int i = firstEntryIndex(); i >= 0; i = getSuccessor(i)) {
          action.accept(key(i));
        }
      }
    }
  }

  Iterator<K> keySetIterator() {
    Map<K, V> delegate = delegateOrNull();
    if (delegate != null) {
      return delegate.keySet().iterator();
    }

    checkNotNull(action);
    for (Node<K, V> node = firstInKeyInsertionOrder;
        node != null;
        node = node.nextInKeyInsertionOrder) {
      action.accept(node.key, node.value);
    }
  }

  @Override
  public void replaceAll(BiFunction<? super K, ? super V, ? extends V> function) {
    checkNotNull(function);
    Node<K, V> oldFirst = firstInKeyInsertionOrder;

        Caused by: java.io.IOException: Failed to delete temp directory /var/folders/_2/vxp7qn2x7qzd0zqqm8p128lh0000gq/T/junit-4205933054320696172.
	        at java.base/java.util.stream.ForEachOps$ForEachOp$OfRef.accept(ForEachOps.java:183)
         */
        .withDebug(true)
        .withArguments(*args, "--stacktrace", "--no-watch-fs")

    private
    fun assertArchivedFilesSeen(vararg archiveFileNames: String) {

     */
    fun followSslRedirects(followProtocolRedirects: Boolean) =
      apply {
        this.followSslRedirects = followProtocolRedirects
      }

    /**
     * Sets the handler that can accept cookies from incoming HTTP responses and provides cookies to
     * outgoing HTTP requests.
     *
     * If unset, [no cookies][CookieJar.NO_COOKIES] will be accepted nor provided.
     */

        session: Annotated[str | None, Cookie()] = None,
        item_id: str,
    ):
        if session is None:
            raise WebSocketException(code=status.WS_1008_POLICY_VIOLATION)
        await websocket.accept()
        while True:
            data = await websocket.receive_text()
            await websocket.send_text(f"Session cookie is: {session}")