return Collections.unmodifiableCollection(collection);
  }

  @Override
  public void clear() {
    // Clear each collection, to make previously returned collections empty.
    for (Collection<V> collection : map.values()) {
      collection.clear();
    }
    map.clear();
    totalSize = 0;
  }

  // Views

  /**
   * {@inheritDoc}
   *

    }

    @Override
    public boolean removeAll(final Collection<?> collection) {
      return removeIf(collection::contains);
    }

    @Override
    public boolean retainAll(final Collection<?> collection) {
      return removeIf(element -> !collection.contains(element));
    }

    @Override

   */
  protected AbstractSetMultimap(Map<K, Collection<V>> map) {
    super(map);
  }

  @Override
  abstract Set<V> createCollection();

  @Override
  Set<V> createUnmodifiableEmptyCollection() {
    return Collections.emptySet();
  }

  @Override
  <E extends @Nullable Object> Collection<E> unmodifiableCollectionSubclass(
      Collection<E> collection) {
    return Collections.unmodifiableSet((Set<E>) collection);
  }

    synchronized (collection) { // for Collections.synchronized
      assertFalse(collection.spliterator().hasCharacteristics(Spliterator.NONNULL));
    }
  }

  @CollectionFeature.Require(SUPPORTS_ADD)
  public void testSpliteratorNotImmutable_CollectionAllowsAdd() {
    // If add is supported, verify that IMMUTABLE is not reported.
    synchronized (collection) { // for Collections.synchronized

                return super.add(element);
              }

              @Override
              public boolean addAll(Collection<? extends Integer> collection) {
                return standardAddAll(collection);
              }
            };
          }
        };

    Map<Color, Collection<Integer>> map = Maps.newEnumMap(Color.class);
    Multimap<Color, Integer> multimap = Multimaps.newMultimap(map, factory);
    try {

      Map<Element, Element> create(Collection<Element> keys) {
        return Collections.unmodifiableMap(Hash.create(keys));
      }
    },
    SyncHM {
      @Override
      Map<Element, Element> create(Collection<Element> keys) {
        return Collections.synchronizedMap(Hash.create(keys));
      }
    },
    Tree {
      @Override
      Map<Element, Element> create(Collection<Element> keys) {

    return suite;
  }

  protected Collection<Method> suppressForEmptyList() {
    return Collections.emptySet();
  }

  protected Collection<Method> suppressForSingletonList() {
    return Collections.emptySet();
  }

  protected Collection<Method> suppressForArraysAsList() {
    return Collections.emptySet();
  }

  protected Collection<Method> suppressForArrayList() {
    return Collections.emptySet();

 *   }
 * }
 * </pre>
 *
 * <p>See semantic details at {@link #create(Collection)}.
 *
 * @author Luiz-Otavio Zorzella
 */
@GwtCompatible
@ElementTypesAreNonnullByDefault
final class ClusterException extends RuntimeException {

  final Collection<? extends Throwable> exceptions;

  private ClusterException(Collection<? extends Throwable> exceptions) {
    super(

    }
  }

  public void testCopyOf_collection_empty() {
    // "<String>" is required to work around a javac 1.5 bug.
    Collection<String> c = MinimalCollection.<String>of();
    List<String> list = ImmutableList.copyOf(c);
    assertEquals(Collections.emptyList(), list);
  }

  public void testCopyOf_collection_oneElement() {
    Collection<String> c = MinimalCollection.of("a");

    @Override
    public Entry<K, Collection<V>>[] createArray(int length) {
      return (Entry<K, Collection<V>>[]) new Entry<?, ?>[length];
    }

    @Override
    public Iterable<Entry<K, Collection<V>>> order(List<Entry<K, Collection<V>>> insertionOrder) {
      Map<K, Collection<V>> map = new HashMap<>();
      List<Entry<K, V>> builder = new ArrayList<>();
      for (Entry<K, Collection<V>> entry : insertionOrder) {