}

  /**
   * This Iterator claims to have more elements than the underlying iterable, but when you try to
   * fetch the extra elements, it throws an unchecked exception.
   */
  static class ThrowsAtEndIterator<E> implements Iterator<E> {
    Iterator<E> iterator;

    public ThrowsAtEndIterator(Iterable<E> iterable) {
      this.iterator = iterable.iterator();
    }

    @Override
    public boolean hasNext() {

    CountingIterable iterable = new CountingIterable();
    List<String> list = ImmutableList.copyOf(iterable);
    assertEquals(asList("a", "b", "a"), list);
  }

  public void testCopyOf_plainIterable_iteratesOnce() {
    CountingIterable iterable = new CountingIterable();
    ImmutableList<String> unused = ImmutableList.copyOf(iterable);
    assertEquals(1, iterable.count);
  }

    UNKNOWN_ORDER
  }

  @SuppressWarnings("unchecked") // TODO(cpovirk): Stop using arrays.
  AbstractIteratorTester(
      int steps,
      Iterable<E> elementsToInsertIterable,
      Iterable<? extends IteratorFeature> features,
      Iterable<E> expectedElements,
      KnownOrder knownOrder,
      int startIndex) {
    // periodically we should manually try (steps * 3 / 2) here; all tests but

    assertEquals(1, iterable.count);
  }

  public void testCopyOf_hashMultiset() {
    Multiset<String> iterable = HashMultiset.create(asList("a", "b", "a"));
    Multiset<String> multiset = ImmutableMultiset.copyOf(iterable);
    assertEquals(HashMultiset.create(asList("a", "b", "a")), multiset);
  }

  public void testCopyOf_treeMultiset() {
    Multiset<String> iterable = TreeMultiset.create(asList("a", "b", "a"));

  }

  public <K, V> void testWhere_actualArgHasWildcard() {
    TypeResolver resolver =
        new TypeResolver()
            .where(
                new TypeCapture<Iterable<Map<?, V>>>() {}.capture(),
                new TypeCapture<Iterable<Map<String, Integer>>>() {}.capture());
    assertEquals(
        new TypeCapture<K>() {}.capture(), resolver.resolveType(new TypeCapture<K>() {}.capture()));

    }
  }

  /**
   * Returns a funnel that processes an {@code Iterable} by funneling its elements in iteration
   * order with the specified funnel. No separators are added between the elements.
   *
   * @since 15.0
   */
  public static <E extends @Nullable Object> Funnel<Iterable<? extends E>> sequentialFunnel(
      Funnel<E> elementFunnel) {
    return new SequentialFunnel<>(elementFunnel);

    SEQUENTIAL {
      @Override
      final <T extends @Nullable Object, A extends @Nullable Object, R extends @Nullable Object>
          A result(Collector<T, A, R> collector, Iterable<T> inputs) {
        A accum = collector.supplier().get();
        for (T input : inputs) {
          collector.accumulator().accept(accum, input);
        }
        return accum;
      }
    },

    }
  }

  /**
   * Returns a funnel that processes an {@code Iterable} by funneling its elements in iteration
   * order with the specified funnel. No separators are added between the elements.
   *
   * @since 15.0
   */
  public static <E extends @Nullable Object> Funnel<Iterable<? extends E>> sequentialFunnel(
      Funnel<E> elementFunnel) {
    return new SequentialFunnel<>(elementFunnel);

 * should use the type safe {@link #putInstance}.
 *
 * <p>Also, if caller suppresses unchecked warnings and passes in an {@code Iterable<String>} for
 * type {@code Iterable<Integer>}, the map won't be able to detect and throw type error.
 *
 * <p>Like any other {@code Map<Class, Object>}, this map may contain entries for primitive types,

 * should use the type safe {@link #putInstance}.
 *
 * <p>Also, if caller suppresses unchecked warnings and passes in an {@code Iterable<String>} for
 * type {@code Iterable<Integer>}, the map won't be able to detect and throw type error.
 *
 * <p>Like any other {@code Map<Class, Object>}, this map may contain entries for primitive types,