/*
    * Copyright (C) 2007 The Guava Authors
    *
    * Licensed under the Apache License, Version 2.0 (the "License");
    * you may not use this file except in compliance with the License.
    * You may obtain a copy of the License at
    *
    * http://www.apache.org/licenses/LICENSE-2.0
    *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   */
  
  package com.google.common.collect;
  
  import static com.google.common.collect.Iterators.advance;
  import static com.google.common.collect.Iterators.get;
  import static com.google.common.collect.Iterators.getLast;
  import static com.google.common.collect.Lists.newArrayList;
  import static com.google.common.truth.Truth.assertThat;
  import static java.util.Arrays.asList;
  
  import com.google.common.annotations.GwtCompatible;
  import com.google.common.base.Function;
  import com.google.common.base.Predicate;
  import com.google.common.base.Predicates;
  
  import junit.framework.AssertionFailedError;
  import junit.framework.TestCase;
  
  import java.util.Collections;
  import java.util.Enumeration;
  import java.util.Iterator;
  import java.util.List;
  import java.util.ListIterator;
  import java.util.NoSuchElementException;
  import java.util.RandomAccess;
  import java.util.Set;
  import java.util.Vector;
  
  /**
   * Unit test for {@code Iterators}.
   *
   * @author Kevin Bourrillion
   */
  @GwtCompatible(emulated = true)
  public class IteratorsTest extends TestCase {
  
    public void testEmptyIterator() {
      Iterator<String> iterator = Iterators.emptyIterator();
      assertFalse(iterator.hasNext());
      try {
        iterator.next();
        fail("no exception thrown");
      } catch (NoSuchElementException expected) {
      }
      try {
        iterator.remove();
        fail("no exception thrown");
      } catch (UnsupportedOperationException expected) {
      }
    }
  
    public void testEmptyListIterator() {
      ListIterator<String> iterator = Iterators.emptyListIterator();
      assertFalse(iterator.hasNext());
      assertFalse(iterator.hasPrevious());
      assertEquals(0, iterator.nextIndex());
      assertEquals(-1, iterator.previousIndex());
      try {
        iterator.next();
        fail("no exception thrown");
      } catch (NoSuchElementException expected) {
      }
      try {
        iterator.previous();
        fail("no exception thrown");
      } catch (NoSuchElementException expected) {
      }
      try {
        iterator.remove();
        fail("no exception thrown");
      } catch (UnsupportedOperationException expected) {
      }
      try {
        iterator.set("a");
        fail("no exception thrown");
      } catch (UnsupportedOperationException expected) {
      }
      try {
        iterator.add("a");
        fail("no exception thrown");
      } catch (UnsupportedOperationException expected) {
      }
    }
  
   public void testEmptyModifiableIterator() {
     Iterator<String> iterator = Iterators.emptyModifiableIterator();
     assertFalse(iterator.hasNext());
     try {
       iterator.next();
       fail("Expected NoSuchElementException");
     } catch (NoSuchElementException expected) {
     }
     try {
       iterator.remove();
       fail("Expected IllegalStateException");
     } catch (IllegalStateException expected) {
     }
   }
 
   public void testSize0() {
     Iterator<String> iterator = Iterators.emptyIterator();
     assertEquals(0, Iterators.size(iterator));
   }
 
   public void testSize1() {
     Iterator<Integer> iterator = Collections.singleton(0).iterator();
     assertEquals(1, Iterators.size(iterator));
   }
 
   public void testSize_partiallyConsumed() {
     Iterator<Integer> iterator = asList(1, 2, 3, 4, 5).iterator();
     iterator.next();
     iterator.next();
     assertEquals(3, Iterators.size(iterator));
   }
 
   public void test_contains_nonnull_yes() {
     Iterator<String> set = asList("a", null, "b").iterator();
     assertTrue(Iterators.contains(set, "b"));
   }
 
   public void test_contains_nonnull_no() {
     Iterator<String> set = asList("a", "b").iterator();
     assertFalse(Iterators.contains(set, "c"));
   }
 
   public void test_contains_null_yes() {
     Iterator<String> set = asList("a", null, "b").iterator();
     assertTrue(Iterators.contains(set, null));
   }
 
   public void test_contains_null_no() {
     Iterator<String> set = asList("a", "b").iterator();
     assertFalse(Iterators.contains(set, null));
   }
 
   public void testGetOnlyElement_noDefault_valid() {
     Iterator<String> iterator = Collections.singletonList("foo").iterator();
     assertEquals("foo", Iterators.getOnlyElement(iterator));
   }
 
   public void testGetOnlyElement_noDefault_empty() {
     Iterator<String> iterator = Iterators.emptyIterator();
     try {
       Iterators.getOnlyElement(iterator);
       fail();
     } catch (NoSuchElementException expected) {
     }
   }
 
   public void testGetOnlyElement_noDefault_moreThanOneLessThanFiveElements() {
     Iterator<String> iterator = asList("one", "two").iterator();
     try {
       Iterators.getOnlyElement(iterator);
       fail();
     } catch (IllegalArgumentException expected) {
       assertEquals("expected one element but was: <one, two>",
                    expected.getMessage());
     }
   }
 
   public void testGetOnlyElement_noDefault_fiveElements() {
     Iterator<String> iterator =
         asList("one", "two", "three", "four", "five").iterator();
     try {
       Iterators.getOnlyElement(iterator);
       fail();
     } catch (IllegalArgumentException expected) {
       assertEquals("expected one element but was: "
                    + "<one, two, three, four, five>",
                    expected.getMessage());
     }
   }
 
   public void testGetOnlyElement_noDefault_moreThanFiveElements() {
     Iterator<String> iterator =
         asList("one", "two", "three", "four", "five", "six").iterator();
     try {
       Iterators.getOnlyElement(iterator);
       fail();
     } catch (IllegalArgumentException expected) {
       assertEquals("expected one element but was: "
                    + "<one, two, three, four, five, ...>",
                    expected.getMessage());
     }
   }
 
   public void testGetOnlyElement_withDefault_singleton() {
     Iterator<String> iterator = Collections.singletonList("foo").iterator();
     assertEquals("foo", Iterators.getOnlyElement(iterator, "bar"));
   }
 
   public void testGetOnlyElement_withDefault_empty() {
     Iterator<String> iterator = Iterators.emptyIterator();
     assertEquals("bar", Iterators.getOnlyElement(iterator, "bar"));
   }
 
   public void testGetOnlyElement_withDefault_empty_null() {
     Iterator<String> iterator = Iterators.emptyIterator();
     assertNull(Iterators.getOnlyElement(iterator, null));
   }
 
   public void testGetOnlyElement_withDefault_two() {
     Iterator<String> iterator = asList("foo", "bar").iterator();
     try {
       Iterators.getOnlyElement(iterator, "x");
       fail();
     } catch (IllegalArgumentException expected) {
       assertEquals("expected one element but was: <foo, bar>",
                    expected.getMessage());
     }
   }
 
   public void testFilterSimple() {
     Iterator<String> unfiltered = Lists.newArrayList("foo", "bar").iterator();
     Iterator<String> filtered = Iterators.filter(unfiltered,
                                                  Predicates.equalTo("foo"));
     List<String> expected = Collections.singletonList("foo");
     List<String> actual = Lists.newArrayList(filtered);
     assertEquals(expected, actual);
   }
 
   public void testFilterNoMatch() {
     Iterator<String> unfiltered = Lists.newArrayList("foo", "bar").iterator();
     Iterator<String> filtered = Iterators.filter(unfiltered,
                                                  Predicates.alwaysFalse());
     List<String> expected = Collections.emptyList();
     List<String> actual = Lists.newArrayList(filtered);
     assertEquals(expected, actual);
   }
 
   public void testFilterMatchAll() {
     Iterator<String> unfiltered = Lists.newArrayList("foo", "bar").iterator();
     Iterator<String> filtered = Iterators.filter(unfiltered,
                                                  Predicates.alwaysTrue());
     List<String> expected = Lists.newArrayList("foo", "bar");
     List<String> actual = Lists.newArrayList(filtered);
     assertEquals(expected, actual);
   }
 
   public void testFilterNothing() {
     Iterator<String> unfiltered = Collections.<String>emptyList().iterator();
     Iterator<String> filtered = Iterators.filter(unfiltered,
         new Predicate<String>() {
           @Override
           public boolean apply(String s) {
             throw new AssertionFailedError("Should never be evaluated");
           }
         });
 
     List<String> expected = Collections.emptyList();
     List<String> actual = Lists.newArrayList(filtered);
     assertEquals(expected, actual);
   }
 
   public void testAny() {
     List<String> list = Lists.newArrayList();
     Predicate<String> predicate = Predicates.equalTo("pants");
 
     assertFalse(Iterators.any(list.iterator(), predicate));
     list.add("cool");
     assertFalse(Iterators.any(list.iterator(), predicate));
     list.add("pants");
     assertTrue(Iterators.any(list.iterator(), predicate));
   }
 
   public void testAll() {
     List<String> list = Lists.newArrayList();
     Predicate<String> predicate = Predicates.equalTo("cool");
 
     assertTrue(Iterators.all(list.iterator(), predicate));
     list.add("cool");
     assertTrue(Iterators.all(list.iterator(), predicate));
     list.add("pants");
     assertFalse(Iterators.all(list.iterator(), predicate));
   }
 
   public void testFind_firstElement() {
     Iterable<String> list = Lists.newArrayList("cool", "pants");
     Iterator<String> iterator = list.iterator();
     assertEquals("cool", Iterators.find(iterator, Predicates.equalTo("cool")));
     assertEquals("pants", iterator.next());
   }
 
   public void testFind_lastElement() {
     Iterable<String> list = Lists.newArrayList("cool", "pants");
     Iterator<String> iterator = list.iterator();
     assertEquals("pants", Iterators.find(iterator,
         Predicates.equalTo("pants")));
     assertFalse(iterator.hasNext());
   }
 
   public void testFind_notPresent() {
     Iterable<String> list = Lists.newArrayList("cool", "pants");
     Iterator<String> iterator = list.iterator();
     try {
       Iterators.find(iterator, Predicates.alwaysFalse());
       fail();
     } catch (NoSuchElementException e) {
     }
     assertFalse(iterator.hasNext());
   }
 
   public void testFind_matchAlways() {
     Iterable<String> list = Lists.newArrayList("cool", "pants");
     Iterator<String> iterator = list.iterator();
     assertEquals("cool", Iterators.find(iterator, Predicates.alwaysTrue()));
   }
 
   public void testFind_withDefault_first() {
     Iterable<String> list = Lists.newArrayList("cool", "pants");
     Iterator<String> iterator = list.iterator();
     assertEquals("cool",
         Iterators.find(iterator, Predicates.equalTo("cool"), "woot"));
     assertEquals("pants", iterator.next());
   }
 
   public void testFind_withDefault_last() {
     Iterable<String> list = Lists.newArrayList("cool", "pants");
     Iterator<String> iterator = list.iterator();
     assertEquals("pants",
         Iterators.find(iterator, Predicates.equalTo("pants"), "woot"));
     assertFalse(iterator.hasNext());
   }
 
   public void testFind_withDefault_notPresent() {
     Iterable<String> list = Lists.newArrayList("cool", "pants");
     Iterator<String> iterator = list.iterator();
     assertEquals("woot",
         Iterators.find(iterator, Predicates.alwaysFalse(), "woot"));
     assertFalse(iterator.hasNext());
   }
 
   public void testFind_withDefault_notPresent_nullReturn() {
     Iterable<String> list = Lists.newArrayList("cool", "pants");
     Iterator<String> iterator = list.iterator();
     assertNull(
         Iterators.find(iterator, Predicates.alwaysFalse(), null));
     assertFalse(iterator.hasNext());
   }
 
   public void testFind_withDefault_matchAlways() {
     Iterable<String> list = Lists.newArrayList("cool", "pants");
     Iterator<String> iterator = list.iterator();
     assertEquals("cool",
         Iterators.find(iterator, Predicates.alwaysTrue(), "woot"));
     assertEquals("pants", iterator.next());
   }
 
   public void testTryFind_firstElement() {
     Iterable<String> list = Lists.newArrayList("cool", "pants");
     Iterator<String> iterator = list.iterator();
     assertEquals("cool",
         Iterators.tryFind(iterator, Predicates.equalTo("cool")).get());
   }
 
   public void testTryFind_lastElement() {
     Iterable<String> list = Lists.newArrayList("cool", "pants");
     Iterator<String> iterator = list.iterator();
     assertEquals("pants",
         Iterators.tryFind(iterator, Predicates.equalTo("pants")).get());
   }
 
   public void testTryFind_alwaysTrue() {
     Iterable<String> list = Lists.newArrayList("cool", "pants");
     Iterator<String> iterator = list.iterator();
     assertEquals("cool",
         Iterators.tryFind(iterator, Predicates.alwaysTrue()).get());
   }
 
   public void testTryFind_alwaysFalse_orDefault() {
     Iterable<String> list = Lists.newArrayList("cool", "pants");
     Iterator<String> iterator = list.iterator();
     assertEquals("woot",
         Iterators.tryFind(iterator, Predicates.alwaysFalse()).or("woot"));
     assertFalse(iterator.hasNext());
   }
 
   public void testTryFind_alwaysFalse_isPresent() {
     Iterable<String> list = Lists.newArrayList("cool", "pants");
     Iterator<String> iterator = list.iterator();
     assertFalse(
         Iterators.tryFind(iterator, Predicates.alwaysFalse()).isPresent());
     assertFalse(iterator.hasNext());
   }
 
   public void testTransform() {
     Iterator<String> input = asList("1", "2", "3").iterator();
     Iterator<Integer> result = Iterators.transform(input,
         new Function<String, Integer>() {
           @Override
           public Integer apply(String from) {
             return Integer.valueOf(from);
           }
         });
 
     List<Integer> actual = Lists.newArrayList(result);
     List<Integer> expected = asList(1, 2, 3);
     assertEquals(expected, actual);
   }
 
   public void testTransformRemove() {
     List<String> list = Lists.newArrayList("1", "2", "3");
     Iterator<String> input = list.iterator();
     Iterator<Integer> iterator = Iterators.transform(input,
         new Function<String, Integer>() {
           @Override
           public Integer apply(String from) {
             return Integer.valueOf(from);
           }
         });
 
     assertEquals(Integer.valueOf(1), iterator.next());
     assertEquals(Integer.valueOf(2), iterator.next());
     iterator.remove();
     assertEquals(asList("1", "3"), list);
   }
 
   public void testPoorlyBehavedTransform() {
     Iterator<String> input = asList("1", null, "3").iterator();
     Iterator<Integer> result = Iterators.transform(input,
         new Function<String, Integer>() {
           @Override
           public Integer apply(String from) {
             return Integer.valueOf(from);
           }
         });
 
     result.next();
     try {
       result.next();
       fail("Expected NFE");
     } catch (NumberFormatException nfe) {
       // Expected to fail.
     }
   }
 
   public void testNullFriendlyTransform() {
     Iterator<Integer> input = asList(1, 2, null, 3).iterator();
     Iterator<String> result = Iterators.transform(input,
         new Function<Integer, String>() {
           @Override
           public String apply(Integer from) {
             return String.valueOf(from);
           }
         });
 
     List<String> actual = Lists.newArrayList(result);
     List<String> expected = asList("1", "2", "null", "3");
     assertEquals(expected, actual);
   }
 
   public void testCycleOfEmpty() {
     // "<String>" for javac 1.5.
     Iterator<String> cycle = Iterators.<String>cycle();
     assertFalse(cycle.hasNext());
   }
 
   public void testCycleOfOne() {
     Iterator<String> cycle = Iterators.cycle("a");
     for (int i = 0; i < 3; i++) {
       assertTrue(cycle.hasNext());
       assertEquals("a", cycle.next());
     }
   }
 
   public void testCycleOfOneWithRemove() {
     Iterable<String> iterable = Lists.newArrayList("a");
     Iterator<String> cycle = Iterators.cycle(iterable);
     assertTrue(cycle.hasNext());
     assertEquals("a", cycle.next());
     cycle.remove();
     assertEquals(Collections.emptyList(), iterable);
     assertFalse(cycle.hasNext());
   }
 
   public void testCycleOfTwo() {
     Iterator<String> cycle = Iterators.cycle("a", "b");
     for (int i = 0; i < 3; i++) {
       assertTrue(cycle.hasNext());
       assertEquals("a", cycle.next());
       assertTrue(cycle.hasNext());
       assertEquals("b", cycle.next());
     }
   }
 
   public void testCycleOfTwoWithRemove() {
     Iterable<String> iterable = Lists.newArrayList("a", "b");
     Iterator<String> cycle = Iterators.cycle(iterable);
     assertTrue(cycle.hasNext());
     assertEquals("a", cycle.next());
     assertTrue(cycle.hasNext());
     assertEquals("b", cycle.next());
     assertTrue(cycle.hasNext());
     assertEquals("a", cycle.next());
     cycle.remove();
     assertEquals(Collections.singletonList("b"), iterable);
     assertTrue(cycle.hasNext());
     assertEquals("b", cycle.next());
     assertTrue(cycle.hasNext());
     assertEquals("b", cycle.next());
     cycle.remove();
     assertEquals(Collections.emptyList(), iterable);
     assertFalse(cycle.hasNext());
   }
 
   public void testCycleRemoveWithoutNext() {
     Iterator<String> cycle = Iterators.cycle("a", "b");
     assertTrue(cycle.hasNext());
     try {
       cycle.remove();
       fail("no exception thrown");
     } catch (IllegalStateException expected) {
     }
   }
 
   public void testCycleRemoveSameElementTwice() {
     Iterator<String> cycle = Iterators.cycle("a", "b");
     cycle.next();
     cycle.remove();
     try {
       cycle.remove();
       fail("no exception thrown");
     } catch (IllegalStateException expected) {
     }
   }
 
   public void testCycleWhenRemoveIsNotSupported() {
     Iterable<String> iterable = asList("a", "b");
     Iterator<String> cycle = Iterators.cycle(iterable);
     cycle.next();
     try {
       cycle.remove();
       fail("no exception thrown");
     } catch (UnsupportedOperationException expected) {
     }
   }
 
   public void testCycleRemoveAfterHasNext() {
     Iterable<String> iterable = Lists.newArrayList("a");
     Iterator<String> cycle = Iterators.cycle(iterable);
     assertTrue(cycle.hasNext());
     assertEquals("a", cycle.next());
     assertTrue(cycle.hasNext());
     cycle.remove();
     assertEquals(Collections.emptyList(), iterable);
     assertFalse(cycle.hasNext());
   }
 
   public void testCycleNoSuchElementException() {
     Iterable<String> iterable = Lists.newArrayList("a");
     Iterator<String> cycle = Iterators.cycle(iterable);
     assertTrue(cycle.hasNext());
     assertEquals("a", cycle.next());
     cycle.remove();
     assertFalse(cycle.hasNext());
     try {
       cycle.next();
       fail();
     } catch (NoSuchElementException expected) {}
   }
 
   /**
    * Illustrates the somewhat bizarre behavior when a null is passed in.
    */
   public void testConcatContainingNull() {
     @SuppressWarnings("unchecked")
     Iterator<Iterator<Integer>> input
         = asList(iterateOver(1, 2), null, iterateOver(3)).iterator();
     Iterator<Integer> result = Iterators.concat(input);
     assertEquals(1, (int) result.next());
     assertEquals(2, (int) result.next());
     try {
       result.hasNext();
       fail("no exception thrown");
     } catch (NullPointerException e) {
     }
     try {
       result.next();
       fail("no exception thrown");
     } catch (NullPointerException e) {
     }
     // There is no way to get "through" to the 3.  Buh-bye
   }
 
   @SuppressWarnings("unchecked")
   public void testConcatVarArgsContainingNull() {
     try {
       Iterators.concat(iterateOver(1, 2), null, iterateOver(3), iterateOver(4),
           iterateOver(5));
       fail("no exception thrown");
     } catch (NullPointerException e) {
     }
   }
 
   public void testAddAllWithEmptyIterator() {
     List<String> alreadyThere = Lists.newArrayList("already", "there");
 
     boolean changed = Iterators.addAll(alreadyThere,
                                        Iterators.<String>emptyIterator());
     assertThat(alreadyThere).has().exactly("already", "there").inOrder();
     assertFalse(changed);
   }
 
   public void testAddAllToList() {
     List<String> alreadyThere = Lists.newArrayList("already", "there");
     List<String> freshlyAdded = Lists.newArrayList("freshly", "added");
 
     boolean changed = Iterators.addAll(alreadyThere, freshlyAdded.iterator());
 
     assertThat(alreadyThere).has().exactly("already", "there", "freshly", "added");
     assertTrue(changed);
   }
 
   public void testAddAllToSet() {
     Set<String> alreadyThere
         = Sets.newLinkedHashSet(asList("already", "there"));
     List<String> oneMore = Lists.newArrayList("there");
 
     boolean changed = Iterators.addAll(alreadyThere, oneMore.iterator());
     assertThat(alreadyThere).has().exactly("already", "there").inOrder();
     assertFalse(changed);
   }
 
   private static Iterator<Integer> iterateOver(final Integer... values) {
     return newArrayList(values).iterator();
   }
 
   public void testElementsEqual() {
     Iterable<?> a;
     Iterable<?> b;
 
     // Base case.
     a = Lists.newArrayList();
     b = Collections.emptySet();
     assertTrue(Iterators.elementsEqual(a.iterator(), b.iterator()));
 
     // A few elements.
     a = asList(4, 8, 15, 16, 23, 42);
     b = asList(4, 8, 15, 16, 23, 42);
     assertTrue(Iterators.elementsEqual(a.iterator(), b.iterator()));
 
     // The same, but with nulls.
     a = asList(4, 8, null, 16, 23, 42);
     b = asList(4, 8, null, 16, 23, 42);
     assertTrue(Iterators.elementsEqual(a.iterator(), b.iterator()));
 
     // Different Iterable types (still equal elements, though).
     a = ImmutableList.of(4, 8, 15, 16, 23, 42);
     b = asList(4, 8, 15, 16, 23, 42);
     assertTrue(Iterators.elementsEqual(a.iterator(), b.iterator()));
 
     // An element differs.
     a = asList(4, 8, 15, 12, 23, 42);
     b = asList(4, 8, 15, 16, 23, 42);
     assertFalse(Iterators.elementsEqual(a.iterator(), b.iterator()));
 
     // null versus non-null.
     a = asList(4, 8, 15, null, 23, 42);
     b = asList(4, 8, 15, 16, 23, 42);
     assertFalse(Iterators.elementsEqual(a.iterator(), b.iterator()));
     assertFalse(Iterators.elementsEqual(b.iterator(), a.iterator()));
 
     // Different lengths.
     a = asList(4, 8, 15, 16, 23);
     b = asList(4, 8, 15, 16, 23, 42);
     assertFalse(Iterators.elementsEqual(a.iterator(), b.iterator()));
     assertFalse(Iterators.elementsEqual(b.iterator(), a.iterator()));
 
     // Different lengths, one is empty.
     a = Collections.emptySet();
     b = asList(4, 8, 15, 16, 23, 42);
     assertFalse(Iterators.elementsEqual(a.iterator(), b.iterator()));
     assertFalse(Iterators.elementsEqual(b.iterator(), a.iterator()));
   }
 
   public void testPartition_badSize() {
     Iterator<Integer> source = Iterators.singletonIterator(1);
     try {
       Iterators.partition(source, 0);
       fail();
     } catch (IllegalArgumentException expected) {
     }
   }
 
   public void testPartition_empty() {
     Iterator<Integer> source = Iterators.emptyIterator();
     Iterator<List<Integer>> partitions = Iterators.partition(source, 1);
     assertFalse(partitions.hasNext());
   }
 
   public void testPartition_singleton1() {
     Iterator<Integer> source = Iterators.singletonIterator(1);
     Iterator<List<Integer>> partitions = Iterators.partition(source, 1);
     assertTrue(partitions.hasNext());
     assertTrue(partitions.hasNext());
     assertEquals(ImmutableList.of(1), partitions.next());
     assertFalse(partitions.hasNext());
   }
 
   public void testPartition_singleton2() {
     Iterator<Integer> source = Iterators.singletonIterator(1);
     Iterator<List<Integer>> partitions = Iterators.partition(source, 2);
     assertTrue(partitions.hasNext());
     assertTrue(partitions.hasNext());
     assertEquals(ImmutableList.of(1), partitions.next());
     assertFalse(partitions.hasNext());
   }
 
   public void testPartition_view() {
     List<Integer> list = asList(1, 2);
     Iterator<List<Integer>> partitions
         = Iterators.partition(list.iterator(), 1);
 
     // Changes before the partition is retrieved are reflected
     list.set(0, 3);
     List<Integer> first = partitions.next();
 
     // Changes after are not
     list.set(0, 4);
 
     assertEquals(ImmutableList.of(3), first);
   }
 
   public void testPaddedPartition_badSize() {
     Iterator<Integer> source = Iterators.singletonIterator(1);
     try {
       Iterators.paddedPartition(source, 0);
       fail();
     } catch (IllegalArgumentException expected) {
     }
   }
 
   public void testPaddedPartition_empty() {
     Iterator<Integer> source = Iterators.emptyIterator();
     Iterator<List<Integer>> partitions = Iterators.paddedPartition(source, 1);
     assertFalse(partitions.hasNext());
   }
 
   public void testPaddedPartition_singleton1() {
     Iterator<Integer> source = Iterators.singletonIterator(1);
     Iterator<List<Integer>> partitions = Iterators.paddedPartition(source, 1);
     assertTrue(partitions.hasNext());
     assertTrue(partitions.hasNext());
     assertEquals(ImmutableList.of(1), partitions.next());
     assertFalse(partitions.hasNext());
   }
 
   public void testPaddedPartition_singleton2() {
     Iterator<Integer> source = Iterators.singletonIterator(1);
     Iterator<List<Integer>> partitions = Iterators.paddedPartition(source, 2);
     assertTrue(partitions.hasNext());
     assertTrue(partitions.hasNext());
     assertEquals(asList(1, null), partitions.next());
     assertFalse(partitions.hasNext());
   }
 
   public void testPaddedPartition_view() {
     List<Integer> list = asList(1, 2);
     Iterator<List<Integer>> partitions
         = Iterators.paddedPartition(list.iterator(), 1);
 
     // Changes before the PaddedPartition is retrieved are reflected
     list.set(0, 3);
     List<Integer> first = partitions.next();
 
     // Changes after are not
     list.set(0, 4);
 
     assertEquals(ImmutableList.of(3), first);
   }
 
   public void testPaddedPartitionRandomAccess() {
     Iterator<Integer> source = asList(1, 2, 3).iterator();
     Iterator<List<Integer>> partitions = Iterators.paddedPartition(source, 2);
     assertTrue(partitions.next() instanceof RandomAccess);
     assertTrue(partitions.next() instanceof RandomAccess);
   }
 
   public void testForArrayEmpty() {
     String[] array = new String[0];
     Iterator<String> iterator = Iterators.forArray(array);
     assertFalse(iterator.hasNext());
     try {
       iterator.next();
       fail();
     } catch (NoSuchElementException expected) {}
   }
 
   public void testForArrayTypical() {
     String[] array = {"foo", "bar"};
     Iterator<String> iterator = Iterators.forArray(array);
     assertTrue(iterator.hasNext());
     assertEquals("foo", iterator.next());
     assertTrue(iterator.hasNext());
     try {
       iterator.remove();
       fail();
     } catch (UnsupportedOperationException expected) {}
     assertEquals("bar", iterator.next());
     assertFalse(iterator.hasNext());
     try {
       iterator.next();
       fail();
     } catch (NoSuchElementException expected) {}
   }
 
   public void testForArrayOffset() {
     String[] array = {"foo", "bar", "cat", "dog"};
     Iterator<String> iterator = Iterators.forArray(array, 1, 2, 0);
     assertTrue(iterator.hasNext());
     assertEquals("bar", iterator.next());
     assertTrue(iterator.hasNext());
     assertEquals("cat", iterator.next());
     assertFalse(iterator.hasNext());
     try {
       Iterators.forArray(array, 2, 3, 0);
       fail();
     } catch (IndexOutOfBoundsException expected) {}
   }
 
   public void testForArrayLength0() {
     String[] array = {"foo", "bar"};
     assertFalse(Iterators.forArray(array, 0, 0, 0).hasNext());
     assertFalse(Iterators.forArray(array, 1, 0, 0).hasNext());
     assertFalse(Iterators.forArray(array, 2, 0, 0).hasNext());
     try {
       Iterators.forArray(array, -1, 0, 0);
       fail();
     } catch (IndexOutOfBoundsException expected) {}
     try {
       Iterators.forArray(array, 3, 0, 0);
       fail();
     } catch (IndexOutOfBoundsException expected) {}
   }
 
   public void testForEnumerationEmpty() {
     Enumeration<Integer> enumer = enumerate();
     Iterator<Integer> iter = Iterators.forEnumeration(enumer);
 
     assertFalse(iter.hasNext());
     try {
       iter.next();
       fail();
     } catch (NoSuchElementException expected) {
     }
   }
 
   public void testForEnumerationSingleton() {
     Enumeration<Integer> enumer = enumerate(1);
     Iterator<Integer> iter = Iterators.forEnumeration(enumer);
 
     assertTrue(iter.hasNext());
     assertTrue(iter.hasNext());
     assertEquals(1, (int) iter.next());
     try {
       iter.remove();
       fail();
     } catch (UnsupportedOperationException expected) {
     }
     assertFalse(iter.hasNext());
     try {
       iter.next();
       fail();
     } catch (NoSuchElementException expected) {
     }
   }
 
   public void testForEnumerationTypical() {
     Enumeration<Integer> enumer = enumerate(1, 2, 3);
     Iterator<Integer> iter = Iterators.forEnumeration(enumer);
 
     assertTrue(iter.hasNext());
     assertEquals(1, (int) iter.next());
     assertTrue(iter.hasNext());
     assertEquals(2, (int) iter.next());
     assertTrue(iter.hasNext());
     assertEquals(3, (int) iter.next());
     assertFalse(iter.hasNext());
   }
 
   public void testAsEnumerationEmpty() {
     Iterator<Integer> iter = Iterators.emptyIterator();
     Enumeration<Integer> enumer = Iterators.asEnumeration(iter);
 
     assertFalse(enumer.hasMoreElements());
     try {
       enumer.nextElement();
       fail();
     } catch (NoSuchElementException expected) {
     }
   }
 
   public void testAsEnumerationSingleton() {
     Iterator<Integer> iter = ImmutableList.of(1).iterator();
     Enumeration<Integer> enumer = Iterators.asEnumeration(iter);
 
     assertTrue(enumer.hasMoreElements());
     assertTrue(enumer.hasMoreElements());
     assertEquals(1, (int) enumer.nextElement());
     assertFalse(enumer.hasMoreElements());
     try {
       enumer.nextElement();
       fail();
     } catch (NoSuchElementException expected) {
     }
   }
 
   public void testAsEnumerationTypical() {
     Iterator<Integer> iter = ImmutableList.of(1, 2, 3).iterator();
     Enumeration<Integer> enumer = Iterators.asEnumeration(iter);
 
     assertTrue(enumer.hasMoreElements());
     assertEquals(1, (int) enumer.nextElement());
     assertTrue(enumer.hasMoreElements());
     assertEquals(2, (int) enumer.nextElement());
     assertTrue(enumer.hasMoreElements());
     assertEquals(3, (int) enumer.nextElement());
     assertFalse(enumer.hasMoreElements());
   }
 
   private static Enumeration<Integer> enumerate(Integer... ints) {
     Vector<Integer> vector = new Vector<Integer>();
     vector.addAll(asList(ints));
     return vector.elements();
   }
 
   public void testToString() {
     Iterator<String> iterator = Lists.newArrayList("yam", "bam", "jam", "ham").iterator();
     assertEquals("[yam, bam, jam, ham]", Iterators.toString(iterator));
   }
 
   public void testToStringWithNull() {
     Iterator<String> iterator = Lists.newArrayList("hello", null, "world").iterator();
     assertEquals("[hello, null, world]", Iterators.toString(iterator));
   }
 
   public void testToStringEmptyIterator() {
     Iterator<String> iterator = Collections.<String>emptyList().iterator();
     assertEquals("[]", Iterators.toString(iterator));
   }
 
   public void testLimit() {
     List<String> list = newArrayList();
     try {
       Iterators.limit(list.iterator(), -1);
       fail("expected exception");
     } catch (IllegalArgumentException expected) {
       // expected
     }
 
     assertFalse(Iterators.limit(list.iterator(), 0).hasNext());
     assertFalse(Iterators.limit(list.iterator(), 1).hasNext());
 
     list.add("cool");
     assertFalse(Iterators.limit(list.iterator(), 0).hasNext());
     assertEquals(list, newArrayList(Iterators.limit(list.iterator(), 1)));
     assertEquals(list, newArrayList(Iterators.limit(list.iterator(), 2)));
 
     list.add("pants");
     assertFalse(Iterators.limit(list.iterator(), 0).hasNext());
     assertEquals(ImmutableList.of("cool"),
         newArrayList(Iterators.limit(list.iterator(), 1)));
     assertEquals(list, newArrayList(Iterators.limit(list.iterator(), 2)));
     assertEquals(list, newArrayList(Iterators.limit(list.iterator(), 3)));
   }
 
   public void testLimitRemove() {
     List<String> list = newArrayList();
     list.add("cool");
     list.add("pants");
     Iterator<String> iterator = Iterators.limit(list.iterator(), 1);
     iterator.next();
     iterator.remove();
     assertFalse(iterator.hasNext());
     assertEquals(1, list.size());
     assertEquals("pants", list.get(0));
   }
 
   public void testGetNext_withDefault_singleton() {
     Iterator<String> iterator = Collections.singletonList("foo").iterator();
     assertEquals("foo", Iterators.getNext(iterator, "bar"));
   }
 
   public void testGetNext_withDefault_empty() {
     Iterator<String> iterator = Iterators.emptyIterator();
     assertEquals("bar", Iterators.getNext(iterator, "bar"));
   }
 
   public void testGetNext_withDefault_empty_null() {
     Iterator<String> iterator = Iterators.emptyIterator();
     assertNull(Iterators.getNext(iterator, null));
   }
 
   public void testGetNext_withDefault_two() {
     Iterator<String> iterator = asList("foo", "bar").iterator();
     assertEquals("foo", Iterators.getNext(iterator, "x"));
   }
 
   public void testGetLast_basic() {
     List<String> list = newArrayList();
     list.add("a");
     list.add("b");
     assertEquals("b", getLast(list.iterator()));
   }
 
   public void testGetLast_exception() {
     List<String> list = newArrayList();
     try {
       getLast(list.iterator());
       fail();
     } catch (NoSuchElementException expected) {
     }
   }
 
   public void testGetLast_withDefault_singleton() {
     Iterator<String> iterator = Collections.singletonList("foo").iterator();
     assertEquals("foo", Iterators.getLast(iterator, "bar"));
   }
 
   public void testGetLast_withDefault_empty() {
     Iterator<String> iterator = Iterators.emptyIterator();
     assertEquals("bar", Iterators.getLast(iterator, "bar"));
   }
 
   public void testGetLast_withDefault_empty_null() {
     Iterator<String> iterator = Iterators.emptyIterator();
     assertNull(Iterators.getLast(iterator, null));
   }
 
   public void testGetLast_withDefault_two() {
     Iterator<String> iterator = asList("foo", "bar").iterator();
     assertEquals("bar", Iterators.getLast(iterator, "x"));
   }
 
   public void testGet_basic() {
     List<String> list = newArrayList();
     list.add("a");
     list.add("b");
     Iterator<String> iterator = list.iterator();
     assertEquals("b", get(iterator, 1));
     assertFalse(iterator.hasNext());
   }
 
   public void testGet_atSize() {
     List<String> list = newArrayList();
     list.add("a");
     list.add("b");
     Iterator<String> iterator = list.iterator();
     try {
       get(iterator, 2);
       fail();
     } catch (IndexOutOfBoundsException expected) {}
     assertFalse(iterator.hasNext());
   }
 
   public void testGet_pastEnd() {
     List<String> list = newArrayList();
     list.add("a");
     list.add("b");
     Iterator<String> iterator = list.iterator();
     try {
       get(iterator, 5);
       fail();
     } catch (IndexOutOfBoundsException expected) {}
     assertFalse(iterator.hasNext());
   }
 
   public void testGet_empty() {
     List<String> list = newArrayList();
     Iterator<String> iterator = list.iterator();
     try {
       get(iterator, 0);
       fail();
     } catch (IndexOutOfBoundsException expected) {}
     assertFalse(iterator.hasNext());
   }
 
   public void testGet_negativeIndex() {
     List<String> list = newArrayList("a", "b", "c");
     Iterator<String> iterator = list.iterator();
     try {
       get(iterator, -1);
       fail();
     } catch (IndexOutOfBoundsException expected) {}
   }
 
   public void testGet_withDefault_basic() {
     List<String> list = newArrayList();
     list.add("a");
     list.add("b");
     Iterator<String> iterator = list.iterator();
     assertEquals("a", get(iterator, 0, "c"));
     assertTrue(iterator.hasNext());
   }
 
   public void testGet_withDefault_atSize() {
     List<String> list = newArrayList();
     list.add("a");
     list.add("b");
     Iterator<String> iterator = list.iterator();
     assertEquals("c", get(iterator, 2, "c"));
     assertFalse(iterator.hasNext());
   }
 
   public void testGet_withDefault_pastEnd() {
     List<String> list = newArrayList();
     list.add("a");
     list.add("b");
     Iterator<String> iterator = list.iterator();
     assertEquals("c", get(iterator, 3, "c"));
     assertFalse(iterator.hasNext());
   }
 
   public void testGet_withDefault_negativeIndex() {
     List<String> list = newArrayList();
     list.add("a");
     list.add("b");
     Iterator<String> iterator = list.iterator();
     try {
       get(iterator, -1, "c");
       fail();
     } catch (IndexOutOfBoundsException expected) {
       // pass
     }
     assertTrue(iterator.hasNext());
   }
 
   public void testAdvance_basic() {
     List<String> list = newArrayList();
     list.add("a");
     list.add("b");
     Iterator<String> iterator = list.iterator();
     advance(iterator, 1);
     assertEquals("b", iterator.next());
   }
 
   public void testAdvance_pastEnd() {
     List<String> list = newArrayList();
     list.add("a");
     list.add("b");
     Iterator<String> iterator = list.iterator();
     advance(iterator, 5);
     assertFalse(iterator.hasNext());
   }
 
   public void testAdvance_illegalArgument() {
     List<String> list = newArrayList("a", "b", "c");
     Iterator<String> iterator = list.iterator();
     try {
       advance(iterator, -1);
       fail();
     } catch (IllegalArgumentException expected) {}
   }
 
   public void testFrequency() {
     List<String> list = newArrayList("a", null, "b", null, "a", null);
     assertEquals(2, Iterators.frequency(list.iterator(), "a"));
     assertEquals(1, Iterators.frequency(list.iterator(), "b"));
     assertEquals(0, Iterators.frequency(list.iterator(), "c"));
     assertEquals(0, Iterators.frequency(list.iterator(), 4.2));
     assertEquals(3, Iterators.frequency(list.iterator(), null));
   }
 
   public void testRemoveAll() {
     List<String> list = newArrayList("a", "b", "c", "d", "e");
     assertTrue(Iterators.removeAll(
         list.iterator(), newArrayList("b", "d", "f")));
     assertEquals(newArrayList("a", "c", "e"), list);
     assertFalse(Iterators.removeAll(
         list.iterator(), newArrayList("x", "y", "z")));
     assertEquals(newArrayList("a", "c", "e"), list);
   }
 
   public void testRemoveIf() {
     List<String> list = newArrayList("a", "b", "c", "d", "e");
     assertTrue(Iterators.removeIf(
         list.iterator(),
         new Predicate<String>() {
           @Override
           public boolean apply(String s) {
             return s.equals("b") || s.equals("d") || s.equals("f");
           }
         }));
     assertEquals(newArrayList("a", "c", "e"), list);
     assertFalse(Iterators.removeIf(
         list.iterator(),
         new Predicate<String>() {
           @Override
           public boolean apply(String s) {
             return s.equals("x") || s.equals("y") || s.equals("z");
           }
         }));
     assertEquals(newArrayList("a", "c", "e"), list);
   }
 
   public void testRetainAll() {
     List<String> list = newArrayList("a", "b", "c", "d", "e");
     assertTrue(Iterators.retainAll(
         list.iterator(), newArrayList("b", "d", "f")));
     assertEquals(newArrayList("b", "d"), list);
     assertFalse(Iterators.retainAll(
         list.iterator(), newArrayList("b", "e", "d")));
     assertEquals(newArrayList("b", "d"), list);
   }
 
   public void testConsumingIterator() {
     // Test data
     List<String> list = Lists.newArrayList("a", "b");
 
     // Test & Verify
     Iterator<String> consumingIterator =
         Iterators.consumingIterator(list.iterator());
 
     assertEquals("Iterators.consumingIterator(...)", consumingIterator.toString());
 
     assertThat(list).has().exactly("a", "b").inOrder();
 
     assertTrue(consumingIterator.hasNext());
     assertThat(list).has().exactly("a", "b").inOrder();
     assertEquals("a", consumingIterator.next());
     assertThat(list).has().item("b");
 
     assertTrue(consumingIterator.hasNext());
     assertEquals("b", consumingIterator.next());
     assertThat(list).isEmpty();
 
     assertFalse(consumingIterator.hasNext());
   }
 
   public void testIndexOf_consumedData() {
     Iterator<String> iterator =
         Lists.newArrayList("manny", "mo", "jack").iterator();
     assertEquals(1, Iterators.indexOf(iterator, Predicates.equalTo("mo")));
     assertEquals("jack", iterator.next());
     assertFalse(iterator.hasNext());
   }
 
   public void testIndexOf_consumedDataWithDuplicates() {
     Iterator<String> iterator =
         Lists.newArrayList("manny", "mo", "mo", "jack").iterator();
     assertEquals(1, Iterators.indexOf(iterator, Predicates.equalTo("mo")));
     assertEquals("mo", iterator.next());
     assertEquals("jack", iterator.next());
     assertFalse(iterator.hasNext());
   }
 
   public void testIndexOf_consumedDataNoMatch() {
     Iterator<String> iterator =
         Lists.newArrayList("manny", "mo", "mo", "jack").iterator();
     assertEquals(-1, Iterators.indexOf(iterator, Predicates.equalTo("bob")));
     assertFalse(iterator.hasNext());
   }
 
   @SuppressWarnings("deprecation")
   public void testUnmodifiableIteratorShortCircuit() {
     Iterator<String> mod = Lists.newArrayList("a", "b", "c").iterator();
     UnmodifiableIterator<String> unmod = Iterators.unmodifiableIterator(mod);
     assertNotSame(mod, unmod);
     assertSame(unmod, Iterators.unmodifiableIterator(unmod));
     assertSame(unmod, Iterators.unmodifiableIterator((Iterator<String>) unmod));
   }
 
   @SuppressWarnings("deprecation")
   public void testPeekingIteratorShortCircuit() {
     Iterator<String> nonpeek = Lists.newArrayList("a", "b", "c").iterator();
     PeekingIterator<String> peek = Iterators.peekingIterator(nonpeek);
     assertNotSame(peek, nonpeek);
     assertSame(peek, Iterators.peekingIterator(peek));
     assertSame(peek, Iterators.peekingIterator((Iterator<String>) peek));
   }
 }