@CollectionSize.Require(SEVERAL)
  public void testClearConcurrentWithIteration() {
    assertThrows(
        ConcurrentModificationException.class,
        () -> {
          Iterator<E> iterator = collection.iterator();
          collection.clear();
          iterator.next();
        });
  }

            DependencyManagement target,
            DependencyManagement source,
            boolean sourceDominant,
            Map<Object, Object> context) {
        Iterator<Dependency> sourceIterator = source.getDependencies().iterator();
        builder.dependencies(target.getDependencies().stream()
                .map(d -> mergeDependency(d, sourceIterator.next(), sourceDominant, context))

      SortedSet<@Nullable Object> self = (SortedSet<@Nullable Object>) this;
      Iterator<?> iterator = self.tailSet(object).iterator();
      if (iterator.hasNext()) {
        Object ceiling = iterator.next();
        if (unsafeCompare(comparator(), ceiling, object) == 0) {
          iterator.remove();
          return true;
        }
      }
    } catch (ClassCastException | NullPointerException e) {

      }
      return result.intValue();
    }

    @Override
    public UnmodifiableIterator<C> iterator() {
      return new AbstractIterator<C>() {
        final Iterator<Range<C>> rangeItr = ranges.iterator();
        Iterator<C> elemItr = emptyIterator();

        @Override
        @CheckForNull
        protected C computeNext() {
          while (!elemItr.hasNext()) {

     *            初期容量
     */
    public CaseInsensitiveSet(final int initialCapacity) {
        map = new CaseInsensitiveMap<>(initialCapacity);
    }

    @Override
    public Iterator<String> iterator() {
        return map.keySet().iterator();
    }

    @Override
    public int size() {
        return map.size();
    }

    @Override
    public boolean isEmpty() {
        return map.isEmpty();
    }

  }

  /**
   * A sensible default implementation of {@link #iterator}, in terms of {@link #listIterator()}. If
   * you override {@link #listIterator()}, you may wish to override {@link #iterator} to forward to
   * this implementation.
   *
   * @since 7.0
   */
  protected Iterator<E> standardIterator() {
    return listIterator();
  }

  /**

    List<Object> list = new ArrayList<>();
    assertEmpty(list);
    assertEmpty(
        new Iterable<Object>() {
          @Override
          public Iterator<Object> iterator() {
            return emptyList().iterator();
          }
        });

    list.add("a");
    try {
      assertEmpty(list);
      throw new Error();
    } catch (AssertionFailedError expected) {
    }
    try {

    List<Object> list = new ArrayList<>();
    assertEmpty(list);
    assertEmpty(
        new Iterable<Object>() {
          @Override
          public Iterator<Object> iterator() {
            return emptyList().iterator();
          }
        });

    list.add("a");
    try {
      assertEmpty(list);
      throw new Error();
    } catch (AssertionFailedError expected) {
    }
    try {

    this.e4 = e4;
  }

  @Override
  public Iterator<E> iterator() {
    return asList().iterator();
  }

  public List<E> asList() {
    return Arrays.asList(e0(), e1(), e2(), e3(), e4());
  }

  public static class Strings extends SampleElements<String> {
    public Strings() {
      // elements aren't sorted, to better test SortedSet iteration ordering
      super("b", "a", "c", "d", "e");
    }

    @Override
    Multiset<E> multiset() {
      return AbstractMultiset.this;
    }

    @Override
    public Iterator<E> iterator() {
      return elementIterator();
    }
  }

  abstract Iterator<E> elementIterator();

  @LazyInit @CheckForNull private transient Set<Entry<E>> entrySet;

  @Override
  public Set<Entry<E>> entrySet() {