import com.google.common.collect.testing.MinimalCollection; //导入依赖的package包/类
@Override
public void setUp() throws Exception {
  super.setUp();

  empty = new Target(emptyCollection(), "empty");
  /*
   * We test that nullSingleton.retainAll(disjointList) does NOT throw a
   * NullPointerException when disjointList does not, so we can't use
   * MinimalCollection, which throws NullPointerException on calls to
   * contains(null).
   */
  List<E> disjointList = Arrays.asList(e3(), e4());
  disjoint = new Target(disjointList, "disjoint");
  superset = new Target(MinimalCollection.of(e0(), e1(), e2(), e3(), e4()), "superset");
  nonEmptyProperSubset = new Target(MinimalCollection.of(e1()), "subset");
  sameElements = new Target(Arrays.asList(createSamplesArray()), "sameElements");
  containsDuplicates =
      new Target(MinimalCollection.of(e0(), e0(), e3(), e3()), "containsDuplicates");
  partialOverlap = new Target(MinimalCollection.of(e2(), e3()), "partialOverlap");
  nullSingleton = new Target(Collections.<E>singleton(null), "nullSingleton");
}
 

import com.google.common.collect.testing.MinimalCollection; //导入依赖的package包/类
@ListFeature.Require(absent = SUPPORTS_ADD_WITH_INDEX)
@CollectionSize.Require(absent = ZERO)
public void testAddAllAtIndex_unsupportedAllPresent() {
  try {
    getList().addAll(0, MinimalCollection.of(e0()));
    fail("addAll(n, allPresent) should throw");
  } catch (UnsupportedOperationException expected) {
  }
  expectUnchanged();
}
 

import com.google.common.collect.testing.MinimalCollection; //导入依赖的package包/类
@ListFeature.Require(SUPPORTS_ADD_WITH_INDEX)
@CollectionSize.Require(absent = ZERO)
public void testAddAllAtIndex_supportedSomePresent() {
  assertTrue(
      "addAll(n, allPresent) should return true",
      getList().addAll(0, MinimalCollection.of(e0(), e3())));
  expectAdded(0, e0(), e3());
}
 

import com.google.common.collect.testing.MinimalCollection; //导入依赖的package包/类
@CollectionFeature.Require(absent = ALLOWS_NULL_QUERIES)
public void testContainsAll_nullNotAllowed() {
  try {
    assertFalse(collection.containsAll(MinimalCollection.of((E) null)));
  } catch (NullPointerException tolerated) {
  }
}
 

import com.google.common.collect.testing.MinimalCollection; //导入依赖的package包/类
public void testCopyOf_collectionContainingNull() {
  Collection<String> c = MinimalCollection.of("a", null, "b");
  try {
    ImmutableList.copyOf(c);
    fail();
  } catch (NullPointerException expected) {
  }
}
 

import com.google.common.collect.testing.MinimalCollection; //导入依赖的package包/类
public void testCopyOf_collection_general() {
  Collection<String> c = MinimalCollection.of("a", "b", "a");
  Set<String> set = copyOf(c);
  assertEquals(2, set.size());
  assertTrue(set.contains("a"));
  assertTrue(set.contains("b"));
}
 

import com.google.common.collect.testing.MinimalCollection; //导入依赖的package包/类
@CollectionFeature.Require(SUPPORTS_REMOVE)
@CollectionSize.Require(absent = {ZERO, ONE})
public void testRemoveAll_duplicate() {
  ArrayWithDuplicate<E> arrayAndDuplicate = createArrayWithDuplicateElement();
  collection = getSubjectGenerator().create(arrayAndDuplicate.elements);
  E duplicate = arrayAndDuplicate.duplicate;

  assertTrue(
      "removeAll(intersectingCollection) should return true",
      getList().removeAll(MinimalCollection.of(duplicate)));
  assertFalse(
      "after removeAll(e), a collection should not contain e even "
          + "if it initially contained e more than once.",
      getList().contains(duplicate));
}
 

import com.google.common.collect.testing.MinimalCollection; //导入依赖的package包/类
@CollectionFeature.Require(SUPPORTS_REMOVE)
public void testRemoveAll_emptyCollection() {
  assertFalse(
      "removeAll(emptyCollection) should return false",
      collection.removeAll(MinimalCollection.of()));
  expectUnchanged();
}
 

import com.google.common.collect.testing.MinimalCollection; //导入依赖的package包/类
@SuppressWarnings("unchecked")
@CollectionFeature.Require(SUPPORTS_REMOVE)
@CollectionSize.Require(SEVERAL)
public void testRetainAll_duplicatesRemoved() {
  E[] array = createSamplesArray();
  array[1] = e0();
  collection = getSubjectGenerator().create(array);
  assertTrue(
      "containsDuplicates.retainAll(subset) should return true",
      collection.retainAll(MinimalCollection.of(e2())));
  expectContents(e2());
}
 

import com.google.common.collect.testing.MinimalCollection; //导入依赖的package包/类
@CollectionFeature.Require(SUPPORTS_REMOVE)
@CollectionSize.Require(absent = ZERO)
public void testRemoveAll_allPresent() {
  assertTrue(
      "removeAll(intersectingCollection) should return true",
      collection.removeAll(MinimalCollection.of(e0())));
  expectMissing(e0());
}
 

import com.google.common.collect.testing.MinimalCollection; //导入依赖的package包/类
@CollectionFeature.Require({SUPPORTS_REMOVE, FAILS_FAST_ON_CONCURRENT_MODIFICATION})
@CollectionSize.Require(SEVERAL)
public void testRemoveAllSomePresentConcurrentWithIteration() {
  try {
    Iterator<E> iterator = collection.iterator();
    assertTrue(collection.removeAll(MinimalCollection.of(e0(), e3())));
    iterator.next();
    fail("Expected ConcurrentModificationException");
  } catch (ConcurrentModificationException expected) {
    // success
  }
}
 

import com.google.common.collect.testing.MinimalCollection; //导入依赖的package包/类
/** Trigger the {@code other.size() >= this.size()} case in {@link AbstractSet#removeAll()}. */
@CollectionFeature.Require(SUPPORTS_REMOVE)
@CollectionSize.Require(absent = ZERO)
public void testRemoveAll_somePresentLargeCollectionToRemove() {
  assertTrue(
      "removeAll(largeIntersectingCollection) should return true",
      collection.removeAll(MinimalCollection.of(e0(), e0(), e0(), e3(), e3(), e3())));
  expectMissing(e0());
}
 

import com.google.common.collect.testing.MinimalCollection; //导入依赖的package包/类
@ListFeature.Require(SUPPORTS_ADD_WITH_INDEX)
public void testAddAllAtIndex_negative() {
  try {
    getList().addAll(-1, MinimalCollection.of(e3()));
    fail("addAll(-1, e) should throw");
  } catch (IndexOutOfBoundsException expected) {
  }
  expectUnchanged();
  expectMissing(e3());
}
 

import com.google.common.collect.testing.MinimalCollection; //导入依赖的package包/类
@CollectionFeature.Require(absent = SUPPORTS_REMOVE)
public void testRemoveAll_unsupportedNonePresent() {
  try {
    assertFalse(
        "removeAll(disjointCollection) should return false or throw "
            + "UnsupportedOperationException",
        collection.removeAll(MinimalCollection.of(e3())));
  } catch (UnsupportedOperationException tolerated) {
  }
  expectUnchanged();
}
 

import com.google.common.collect.testing.MinimalCollection; //导入依赖的package包/类
@CollectionFeature.Require(absent = SUPPORTS_REMOVE)
@CollectionSize.Require(absent = ZERO)
public void testRemoveAll_unsupportedPresent() {
  try {
    collection.removeAll(MinimalCollection.of(e0()));
    fail("removeAll(intersectingCollection) should throw UnsupportedOperationException");
  } catch (UnsupportedOperationException expected) {
  }
  expectUnchanged();
  assertTrue(collection.contains(e0()));
}
 

import com.google.common.collect.testing.MinimalCollection; //导入依赖的package包/类
@CollectionFeature.Require(value = SUPPORTS_REMOVE, absent = ALLOWS_NULL_QUERIES)
public void testRemoveAll_containsNullNo() {
  MinimalCollection<?> containsNull = MinimalCollection.of((Object) null);
  try {
    assertFalse(
        "removeAll(containsNull) should return false or throw",
        collection.removeAll(containsNull));
  } catch (NullPointerException tolerated) {
  }
  expectUnchanged();
}
 

import com.google.common.collect.testing.MinimalCollection; //导入依赖的package包/类
@CollectionFeature.Require(SUPPORTS_REMOVE)
public void testRemoveAll_containsWrongType() {
  try {
    assertFalse(
        "removeAll(containsWrongType) should return false or throw",
        collection.removeAll(MinimalCollection.of(WrongType.VALUE)));
  } catch (ClassCastException tolerated) {
  }
  expectUnchanged();
}
 

import com.google.common.collect.testing.MinimalCollection; //导入依赖的package包/类
@CollectionFeature.Require(SUPPORTS_ADD)
@CollectionSize.Require(absent = ZERO)
public void testAddAll_supportedAllPresent() {
  assertTrue(
      "addAll(allPresent) should return true", getList().addAll(MinimalCollection.of(e0())));
  expectAdded(e0());
}
 

import com.google.common.collect.testing.MinimalCollection; //导入依赖的package包/类
@ListFeature.Require(absent = SUPPORTS_ADD_WITH_INDEX)
@CollectionSize.Require(absent = ZERO)
public void testAddAllAtIndex_unsupportedSomePresent() {
  try {
    getList().addAll(0, MinimalCollection.of(e0(), e3()));
    fail("addAll(n, allPresent) should throw");
  } catch (UnsupportedOperationException expected) {
  }
  expectUnchanged();
  expectMissing(e3());
}
 

import com.google.common.collect.testing.MinimalCollection; //导入依赖的package包/类
@ListFeature.Require(SUPPORTS_ADD_WITH_INDEX)
@CollectionSize.Require(absent = ZERO)
public void testAddAllAtIndex_supportedAllPresent() {
  assertTrue(
      "addAll(n, allPresent) should return true",
      getList().addAll(0, MinimalCollection.of(e0())));
  expectAdded(0, e0());
}