Collection<String> scopesToCollect, Collection<String> scopesToResolve) {
        return scopesToCollectForAggregatedProjects.addAll(scopesToCollect)
                || scopesToResolveForAggregatedProjects.addAll(scopesToResolve);
    }

    public void synchronizeWithProjectState() {
        lastDependencyArtifacts = project.getDependencyArtifacts();

      throw new IllegalArgumentException("Key does not satisfy predicate: " + key);
    }

    @Override
    public boolean addAll(Collection<? extends V> collection) {
      addAll(0, collection);
      return true;
    }

    @CanIgnoreReturnValue
    @Override
    public boolean addAll(int index, Collection<? extends V> elements) {
      checkNotNull(elements);
      checkPositionIndex(index, 0);

      return this;
    }

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

    @CanIgnoreReturnValue
    Builder<E> combine(Builder<E> builder) {
      checkNotNull(builder);
      contents.addAll(builder.contents);
      return this;
    }

    @Override

        ImmutableSortedMultiset.<String>naturalOrder().addAll(a).addAll(b).build();
    assertEquals(HashMultiset.create(asList("a", "b", "b", "b", "c")), multiset);
  }

  public void testBuilderAddAllIterator() {
    Iterator<String> iterator = asList("a", "b", "a", "c").iterator();
    ImmutableSortedMultiset<String> multiset =
        ImmutableSortedMultiset.<String>naturalOrder().addAll(iterator).build();

    assertThat(mmHeap.peek()).isNull();
    assertThat(mmHeap.poll()).isNull();
  }

  public void testRemove() {
    MinMaxPriorityQueue<Integer> mmHeap = MinMaxPriorityQueue.create();
    mmHeap.addAll(Lists.newArrayList(1, 2, 3, 4, 47, 1, 5, 3, 0));
    assertTrue("Heap is not intact initially", mmHeap.isIntact());
    assertEquals(9, mmHeap.size());
    mmHeap.remove(5);
    assertEquals(8, mmHeap.size());

                    resolvedOptionalProjects.add(optSelectedProject.get());
                    if (activation.activationSettings().recurse()) {
                        resolvedOptionalProjects.addAll(getChildProjects(optSelectedProject.get(), request));
                    }
                } else {
                    unresolvedSelectors.add(activation);
                }
            }
        }

              @Override
              public Collection<String> create(String[] elements) {
                List<String> unfiltered = new ArrayList<>();
                unfiltered.add("yyy");
                Collections.addAll(unfiltered, elements);
                unfiltered.add("zzz");
                return Collections2.filter(unfiltered, NOT_YYY_ZZZ);
              }
            })
        .named("Collections2.filter")

        Collection<String> versions = new LinkedHashSet<>();

        if (buildReactor != null) {
            versions.addAll(buildReactor.findVersions(artifact));
        }

        if (ideWorkspace != null) {
            versions.addAll(ideWorkspace.findVersions(artifact));
        }

        versions.addAll(userLocalArtifactRepository.findVersions(artifact));

        return Collections.unmodifiableList(new ArrayList<>(versions));

        Set<Path> mergedProcessed = new HashSet<>(this.processedPoms);
        mergedProcessed.addAll(other.processedPoms);

        Set<Path> mergedModified = new HashSet<>(this.modifiedPoms);
        mergedModified.addAll(other.modifiedPoms);

        Set<Path> mergedErrors = new HashSet<>(this.errorPoms);
        mergedErrors.addAll(other.errorPoms);

        return new UpgradeResult(mergedProcessed, mergedModified, mergedErrors);

                    request.addr = NbtAddress.getWINSAddress();
                }
            }
        }
    }

    NbtAddress[] getAllByName(final Name name, final InetAddress addr) throws UnknownHostException {
        int n;
        final NameQueryRequest request = new NameQueryRequest(name);
        final NameQueryResponse response = new NameQueryResponse();

        request.addr = addr != null ? addr : NbtAddress.getWINSAddress();