Cache<Integer, Integer> cache =
        CacheBuilder.newBuilder().expireAfterWrite(1000, MILLISECONDS).ticker(fakeTicker).build();

    cache.put(10, 20);
    Iterator<Integer> iterator = cache.asMap().values().iterator();
    iterator.next();
    iterator.remove();

    assertEquals(0, cache.size());
  }

        // Act: create iterator and enumerate
        DirFileEntryEnumIterator2 it = new DirFileEntryEnumIterator2(tree, parent, wildcard, (ResourceNameFilter) null, 0);

        // Assert: first page
        assertTrue(it.hasNext(), "Iterator should have first element");
        assertSame(fe1, it.next(), "First element must match first page");
        assertTrue(it.hasNext(), "Iterator should have second element");

  public void testRemoveAllSomePresentConcurrentWithIteration() {
    assertThrows(
        ConcurrentModificationException.class,
        () -> {
          Iterator<E> iterator = collection.iterator();
          assertTrue(collection.removeAll(MinimalCollection.of(e0(), e3())));
          iterator.next();
        });
  }

  /** Trigger the {@code other.size() >= this.size()} case in {@link AbstractSet#removeAll}. */

   * queue's iterator:
   *
   * {@snippet :
   * Queue<E> queue = Queues.synchronizedQueue(MinMaxPriorityQueue.<E>create());
   * ...
   * queue.add(element);  // Needn't be in synchronized block
   * ...
   * synchronized (queue) {  // Must synchronize on queue!
   *   Iterator<E> i = queue.iterator(); // Must be in synchronized block
   *   while (i.hasNext()) {

      return standardToString();
    }

    @Override
    public Set<Entry<K, V>> entrySet() {
      return new StandardEntrySet() {
        @Override
        public Iterator<Entry<K, V>> iterator() {
          return backingMap.entrySet().iterator();
        }
      };
    }

    @Override
    public void clear() {
      standardClear();
    }

    @Override
    public boolean isEmpty() {

    }
  }

  /** Overridden column iterator to return columns values in globally sorted order. */
  @Override
  Iterator<C> createColumnKeyIterator() {
    Comparator<? super C> comparator = columnComparator();

    Iterator<C> merged =
        mergeSorted(
            transform(backingMap.values(), (Map<C, V> input) -> input.keySet().iterator()),
            comparator);

            Currency.PESO, Country.CHILE,
            Currency.FRANC, Country.SWITZERLAND);
    EnumBiMap<Currency, Country> bimap = EnumBiMap.create(map);

    Iterator<Currency> iter = bimap.keySet().iterator();
    assertEquals(Currency.DOLLAR, iter.next());
    iter.remove();

    // forward map ordered by currency
    assertThat(bimap.keySet()).containsExactly(Currency.FRANC, Currency.PESO).inOrder();

  }

  @Override
  public int hashCode() {
    return delegate().hashCode();
  }

  /**
   * A sensible definition of {@link #removeAll} in terms of {@link #iterator} and {@link #remove}.
   * If you override {@code iterator} or {@code remove}, you may wish to override {@link #removeAll}
   * to forward to this implementation.
   *
   * @since 7.0 (this version overrides the {@code ForwardingCollection} version as of 12.0)

    }
  }

  /** Overridden column iterator to return columns values in globally sorted order. */
  @Override
  Iterator<C> createColumnKeyIterator() {
    Comparator<? super C> comparator = columnComparator();

    Iterator<C> merged =
        mergeSorted(
            transform(backingMap.values(), (Map<C, V> input) -> input.keySet().iterator()),
            comparator);

        return MutableClassToInstanceMap.this.delegate().entrySet();
      }

      @Override
      public Iterator<Entry<Class<? extends @NonNull B>, B>> iterator() {
        return new TransformedIterator<
            Entry<Class<? extends @NonNull B>, B>, Entry<Class<? extends @NonNull B>, B>>(
            delegate().iterator()) {
          @Override
          Entry<Class<? extends @NonNull B>, B> transform(