collect/testing/IteratorTesterTest.java

/*
 * Copyright (C) 2008 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.testing;

import static com.google.common.collect.Lists.newArrayList;
import static com.google.common.collect.testing.IteratorFeature.MODIFIABLE;
import static java.util.Collections.emptyList;

import com.google.common.annotations.GwtCompatible;
import com.google.common.collect.ImmutableList;
import com.google.common.collect.Lists;

import junit.framework.AssertionFailedError;
import junit.framework.TestCase;

import java.util.Iterator;
import java.util.List;
import java.util.NoSuchElementException;

/**
 * Unit test for IteratorTester.
 *
 * @author Mick Killianey
 */
@GwtCompatible
@SuppressWarnings("serial") // No serialization is used in this test
public class IteratorTesterTest extends TestCase {

  public void testCanCatchDifferentLengthOfIteration() {
    IteratorTester<Integer> tester =
        new IteratorTester<Integer>(4, MODIFIABLE, newArrayList(1, 2, 3),
            IteratorTester.KnownOrder.KNOWN_ORDER) {
          @Override protected Iterator<Integer> newTargetIterator() {
            return Lists.newArrayList(1, 2, 3, 4).iterator();
          }
        };
    assertFailure(tester);
  }

  public void testCanCatchDifferentContents() {
    IteratorTester<Integer> tester =
        new IteratorTester<Integer>(3, MODIFIABLE, newArrayList(1, 2, 3),
            IteratorTester.KnownOrder.KNOWN_ORDER) {
          @Override protected Iterator<Integer> newTargetIterator() {
            return Lists.newArrayList(1, 3, 2).iterator();
          }
        };
    assertFailure(tester);
  }

  public void testCanCatchDifferentRemoveBehaviour() {
    IteratorTester<Integer> tester =
        new IteratorTester<Integer>(3, MODIFIABLE, newArrayList(1, 2),
            IteratorTester.KnownOrder.KNOWN_ORDER) {
          @Override protected Iterator<Integer> newTargetIterator() {
            return ImmutableList.of(1, 2).iterator();
          }
        };
    assertFailure(tester);
  }

  public void testUnknownOrder() {
    new IteratorTester<Integer>(3, MODIFIABLE, newArrayList(1, 2),
        IteratorTester.KnownOrder.UNKNOWN_ORDER) {
      @Override protected Iterator<Integer> newTargetIterator() {
        return newArrayList(2, 1).iterator();
      }
    }.test();
  }

  public void testUnknownOrderUnrecognizedElement() {
    IteratorTester<Integer> tester =
        new IteratorTester<Integer>(3, MODIFIABLE, newArrayList(1, 2, 50),
            IteratorTester.KnownOrder.UNKNOWN_ORDER) {
          @Override protected Iterator<Integer> newTargetIterator() {
            return newArrayList(2, 1, 3).iterator();
          }
        };
    assertFailure(tester);
  }

  /**
   * This Iterator wraps another iterator and gives it a bug found
   * in JDK6.
   *
   * <p>This bug is this: if you create an iterator from a TreeSet
   * and call next() on that iterator when hasNext() is false, so
   * that next() throws a NoSuchElementException, then subsequent
   * calls to remove() will incorrectly throw an IllegalStateException,
   * instead of removing the last element returned.
   *
   * <p>See
   * <a href="http://bugs.sun.com/bugdatabase/view_bug.do?bug_id=6529795">
   * Sun bug 6529795</a>
   */
  static class IteratorWithSunJavaBug6529795<T> implements Iterator<T> {
    Iterator<T> iterator;
    boolean nextThrewException;
    IteratorWithSunJavaBug6529795(Iterator<T> iterator) {
      this.iterator = iterator;
    }

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

    @Override
    public T next() {
      try {
        return iterator.next();
      } catch (NoSuchElementException e) {
        nextThrewException = true;
        throw e;
      }
    }

    @Override
    public void remove() {
      if (nextThrewException) {
        throw new IllegalStateException();
      }
      iterator.remove();
    }
  }

  public void testCanCatchSunJavaBug6529795InTargetIterator() {
    try {
      /* Choose 4 steps to get sequence [next, next, next, remove] */
      new IteratorTester<Integer>(4, MODIFIABLE, newArrayList(1, 2),
          IteratorTester.KnownOrder.KNOWN_ORDER) {
        @Override protected Iterator<Integer> newTargetIterator() {
          Iterator<Integer> iterator = Lists.newArrayList(1, 2).iterator();
          return new IteratorWithSunJavaBug6529795<Integer>(iterator);
        }
      }.test();
    } catch (AssertionFailedError e) {
      return;
    }
    fail("Should have caught jdk6 bug in target iterator");
  }

  public void testCanWorkAroundSunJavaBug6529795InTargetIterator() {
    IteratorTester<Integer> tester =
        new IteratorTester<Integer>(4, MODIFIABLE, newArrayList(1, 2),
            IteratorTester.KnownOrder.KNOWN_ORDER) {
          @Override protected Iterator<Integer> newTargetIterator() {
            Iterator<Integer> iterator = Lists.newArrayList(1, 2).iterator();
            return new IteratorWithSunJavaBug6529795<Integer>(iterator);
          }
        };

    /*
     * Calling this method on an IteratorTester should avoid flagging
     * the bug exposed by the preceding test.
     */
    tester.ignoreSunJavaBug6529795();

    tester.test();
  }

  private static final int STEPS = 3;
  static class TesterThatCountsCalls extends IteratorTester<Integer> {
    TesterThatCountsCalls() {
      super(STEPS, MODIFIABLE, newArrayList(1),
          IteratorTester.KnownOrder.KNOWN_ORDER);
    }
    int numCallsToNewTargetIterator;
    int numCallsToVerify;
    @Override protected Iterator<Integer> newTargetIterator() {
      numCallsToNewTargetIterator++;
      return Lists.newArrayList(1).iterator();
    }
    @Override protected void verify(List<Integer> elements) {
      numCallsToVerify++;
      super.verify(elements);
    }
  }

  public void testVerifyGetsCalled() {
    TesterThatCountsCalls tester = new TesterThatCountsCalls();

    tester.test();

    assertEquals("Should have verified once per stimulus executed",
        tester.numCallsToVerify,
        tester.numCallsToNewTargetIterator * STEPS);
  }

  public void testVerifyCanThrowAssertionThatFailsTest() {
    final String message = "Important info about why verify failed";
    IteratorTester<Integer> tester =
        new IteratorTester<Integer>(1, MODIFIABLE, newArrayList(1, 2, 3),
            IteratorTester.KnownOrder.KNOWN_ORDER) {
          @Override protected Iterator<Integer> newTargetIterator() {
            return Lists.newArrayList(1, 2, 3).iterator();
          }

          @Override protected void verify(List<Integer> elements) {
            throw new AssertionFailedError(message);
          }
        };
    AssertionFailedError actual = null;
    try {
      tester.test();
    } catch (AssertionFailedError e) {
      actual = e;
    }
    assertNotNull("verify() should be able to cause test failure", actual);
    assertTrue("AssertionFailedError should have info about why test failed",
        actual.getCause().getMessage().contains(message));
  }

  public void testMissingException() {
    List<Integer> emptyList = newArrayList();

    IteratorTester<Integer> tester =
        new IteratorTester<Integer>(1, MODIFIABLE, emptyList,
            IteratorTester.KnownOrder.KNOWN_ORDER) {
          @Override protected Iterator<Integer> newTargetIterator() {
            return new Iterator<Integer>() {
              @Override
              public void remove() {
                // We should throw here, but we won't!
              }
              @Override
              public Integer next() {
                // We should throw here, but we won't!
                return null;
              }
              @Override
              public boolean hasNext() {
                return false;
              }
            };
          }
        };
    assertFailure(tester);
  }

  public void testUnexpectedException() {
    IteratorTester<Integer> tester =
        new IteratorTester<Integer>(1, MODIFIABLE, newArrayList(1),
            IteratorTester.KnownOrder.KNOWN_ORDER) {
          @Override protected Iterator<Integer> newTargetIterator() {
            return new ThrowingIterator<Integer>(new IllegalStateException());
          }
        };
    assertFailure(tester);
  }

  public void testSimilarException() {
    List<Integer> emptyList = emptyList();
    IteratorTester<Integer> tester =
        new IteratorTester<Integer>(1, MODIFIABLE, emptyList,
            IteratorTester.KnownOrder.KNOWN_ORDER) {
          @Override protected Iterator<Integer> newTargetIterator() {
            return new Iterator<Integer>() {
              @Override
              public void remove() {
                throw new IllegalStateException() { /* subclass */};
              }
              @Override
              public Integer next() {
                throw new NoSuchElementException() { /* subclass */};
              }
              @Override
              public boolean hasNext() {
                return false;
              }
            };
          }
        };
    tester.test();
  }

  public void testMismatchedException() {
    List<Integer> emptyList = emptyList();
    IteratorTester<Integer> tester =
        new IteratorTester<Integer>(1, MODIFIABLE, emptyList,
            IteratorTester.KnownOrder.KNOWN_ORDER) {
          @Override protected Iterator<Integer> newTargetIterator() {
            return new Iterator<Integer>() {
              @Override
              public void remove() {
                // Wrong exception type.
                throw new IllegalArgumentException();
              }
              @Override
              public Integer next() {
                // Wrong exception type.
                throw new UnsupportedOperationException();
              }
              @Override
              public boolean hasNext() {
                return false;
              }
            };
          }
        };
    assertFailure(tester);
  }

  private static void assertFailure(IteratorTester<?> tester) {
    try {
      tester.test();
      fail();
    } catch (AssertionFailedError expected) {
    }
  }

  private static final class ThrowingIterator<E> implements Iterator<E> {
    private final RuntimeException ex;

    private ThrowingIterator(RuntimeException ex) {
      this.ex = ex;
    }

    @Override
    public boolean hasNext() {
      // IteratorTester doesn't expect exceptions for hasNext().
      return true;
    }

    @Override
    public E next() {
      ex.fillInStackTrace();
      throw ex;
    }

    @Override
    public void remove() {
      ex.fillInStackTrace();
      throw ex;
    }
  }
}