return size;
  }

  private abstract static class BiIterator<
          K extends @Nullable Object, V extends @Nullable Object, T extends @Nullable Object>
      implements Iterator<T> {
    final HashBiMap<K, V> biMap;

    @Nullable Node<K, V> next;
    @Nullable Node<K, V> toRemove;
    int expectedModCount;
    int remaining;

    BiIterator(HashBiMap<K, V> biMap) {
      this.biMap = biMap;

   */
  static class IteratorWithJdkBug6529795<T> implements Iterator<T> {
    Iterator<T> iterator;
    boolean nextThrewException;

    IteratorWithJdkBug6529795(Iterator<T> iterator) {
      this.iterator = iterator;
    }

    @Override
    public boolean hasNext() {
      return iterator.hasNext();
    }

    @Override
    public T next() {
      try {

    Map<R, V> output = new LinkedHashMap<>();
    Iterator<Entry<R, Map<C, V>>> iterator = backingMap.entrySet().iterator();
    while (iterator.hasNext()) {
      Entry<R, Map<C, V>> entry = iterator.next();
      V value = entry.getValue().remove(column);
      if (value != null) {
        output.put(entry.getKey(), value);
        if (entry.getValue().isEmpty()) {
          iterator.remove();
        }
      }
    }

    Iterator<List<Integer>> permutations = permutationSet.iterator();
    assertNextPermutation(Collections.<Integer>emptyList(), permutations);
    assertNoMorePermutations(permutations);
  }

  public void testPermutationSetOneElement() {
    Iterator<List<Integer>> permutations =
        Collections2.permutations(Collections.<Integer>singletonList(1)).iterator();

  public void testCopyOf_iterator_empty() {
    Iterator<String> iterator = emptyIterator();
    Set<String> set = copyOf(iterator);
    assertEquals(Collections.<String>emptySet(), set);
    assertThat(set).isSameInstanceAs(this.<String>of());
  }

  public void testCopyOf_iterator_oneElement() {
    Iterator<String> iterator = singletonIterator("a");
    Set<String> set = copyOf(iterator);
    assertEquals(singleton("a"), set);
  }

    }
  }

  /**
   * Verifies that an Iterator is unmodifiable.
   *
   * <p>This test only works with iterators that iterate over a finite set.
   */
  public static void assertIteratorIsUnmodifiable(Iterator<?> iterator) {
    while (iterator.hasNext()) {
      iterator.next();
      try {
        iterator.remove();
        fail("Remove on unmodifiable iterator succeeded");

        @Override
        @Nullable N visitNext(Deque<Iterator<? extends N>> horizon) {
          Iterator<? extends N> top = horizon.getFirst();
          if (top.hasNext()) {
            return checkNotNull(top.next());
          }
          horizon.removeFirst();
          return null;
        }
      };
    }

    final Iterator<N> breadthFirst(Iterator<? extends N> startNodes) {

    FluentIterable<Integer> cycle = fluent(1, 2).cycle();
    Iterator<Integer> iterator = cycle.iterator();
    iterator.next();
    iterator.remove();
    iterator.next();
    iterator.remove();
    assertFalse(iterator.hasNext());
    assertFalse(cycle.iterator().hasNext());
  }

  public void testAppend() {
    FluentIterable<Integer> result =

    Collection<V> getDelegate() {
      return delegate;
    }

    @Override
    public Iterator<V> iterator() {
      refreshIfEmpty();
      return new WrappedIterator();
    }

    /** Collection iterator for {@code WrappedCollection}. */
    class WrappedIterator implements Iterator<V> {
      final Iterator<V> delegateIterator;
      final Collection<V> originalDelegate = delegate;

      WrappedIterator() {

    assertThat(j.join(ImmutableMultimap.of("", "").entries())).isEqualTo(":");
    assertThat(j.join(ImmutableMultimap.of("", "").entries().iterator())).isEqualTo(":");
    assertThat(j.join(ImmutableMultimap.of("1", "a", "1", "b").entries())).isEqualTo("1:a;1:b");
    assertThat(j.join(ImmutableMultimap.of("1", "a", "1", "b").entries().iterator()))
        .isEqualTo("1:a;1:b");