*/
    @CanIgnoreReturnValue
    @Override
    public Builder<E> addAll(Iterator<? extends E> elements) {
      super.addAll(elements);
      return this;
    }

    @CanIgnoreReturnValue
    Builder<E> combine(Builder<E> other) {
      addAll(other.contents, other.size);
      return this;
    }

    /**

   *
   * <p>This is equivalent to calling {@link #add} on each of the ranges in {@code other} in turn.
   *
   * @throws UnsupportedOperationException if this range set does not support the {@code addAll}
   *     operation
   */
  void addAll(RangeSet<C> other);

  /**
   * Adds all of the specified ranges to this range set (optional operation). After this operation,

            List<MavenProject> allProjects = graph.getAllProjects();
            excludedProjects.addAll(
                    projectSelector.getRequiredProjectsBySelectors(request, allProjects, requiredSelectors));
            excludedProjects.addAll(
                    projectSelector.getOptionalProjectsBySelectors(request, allProjects, optionalSelectors));

            map.put("id", UPLOAD);
            map.put("name", "");
            map.put("version", "");
            result.add(map);
            try {
                result.addAll(getAllAvailableArtifacts());
            } catch (final Exception e) {
                saveError(messages -> messages.addErrorsFailedToFindPlugins(GLOBAL));
                logger.warn("Failed to access a plugin repository.", e);

            }
        }

        private <Q> Supplier<Q> getBeanSupplier(Dependency<Q> dep, Key<Q> key) {
            List<Binding<?>> list = new ArrayList<>();
            // Add DI bindings
            list.addAll(getBindings().getOrDefault(key, Set.of()));
            // Add Plexus bindings
            for (var bean : locator.get().locate(toGuiceKey(key))) {
                if (isPlexusBean(bean)) {

  }

  @Override
  public boolean add(@Nullable E o) {
    assertTrue(Thread.holdsLock(mutex));
    return super.add(o);
  }

  @Override
  public boolean addAll(Collection<? extends E> c) {
    assertTrue(Thread.holdsLock(mutex));
    return super.addAll(c);
  }

  @Override
  public void clear() {
    assertTrue(Thread.holdsLock(mutex));
    super.clear();
  }

  @Override

   * This method is not actually very useful and will likely be deprecated in the future.
   */
  @SuppressWarnings("NonApiType") // acts as a direct substitute for a constructor call
  public static <E extends @Nullable Object> HashSet<E> newHashSet(E... elements) {
    HashSet<E> set = newHashSetWithExpectedSize(elements.length);
    Collections.addAll(set, elements);
    return set;
  }

    ArrayList<E> list = new ArrayList<>(capacity);
    Collections.addAll(list, elements);
    return list;
  }

  /**
   * Creates a <i>mutable</i> {@code ArrayList} instance containing the given elements; a very thin
   * shortcut for creating an empty list then calling {@link Iterables#addAll}.
   *
   * <p><b>Note:</b> if mutability is not required and the elements are non-null, use {@link

  @Override
  protected List<Class<? extends AbstractTester>> getTesters() {
    List<Class<? extends AbstractTester>> testers = new ArrayList<>();
    if (runCollectionTests) {
      testers.addAll(super.getTesters());
    }

    testers.add(QueueElementTester.class);
    testers.add(QueueOfferTester.class);
    testers.add(QueuePeekTester.class);
    testers.add(QueuePollTester.class);

    if (elements instanceof Collection) {
      return new ArrayDeque<>((Collection<? extends E>) elements);
    }
    ArrayDeque<E> deque = new ArrayDeque<>();
    Iterables.addAll(deque, elements);
    return deque;
  }

  // ConcurrentLinkedQueue

  /** Creates an empty {@code ConcurrentLinkedQueue}. */
  @J2ktIncompatible
  @GwtIncompatible // ConcurrentLinkedQueue