Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  /*
   * 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 java.util.List;
Unit test for IteratorTester.

Author(s):
Mick Killianey
 
 @SuppressWarnings("serial"// No serialization is used in this test
 public class IteratorTesterTest extends TestCase {
 
     IteratorTester<Integertester =
         new IteratorTester<Integer>(4, newArrayList(1, 2, 3),
             ..) {
           @Override protected Iterator<IntegernewTargetIterator() {
             return Lists.newArrayList(1, 2, 3, 4).iterator();
           }
         };
     assertFailure(tester);
   }
 
   public void testCanCatchDifferentContents() {
     IteratorTester<Integertester =
         new IteratorTester<Integer>(3, newArrayList(1, 2, 3),
             ..) {
           @Override protected Iterator<IntegernewTargetIterator() {
             return Lists.newArrayList(1, 3, 2).iterator();
           }
         };
     assertFailure(tester);
   }
 
     IteratorTester<Integertester =
         new IteratorTester<Integer>(3, newArrayList(1, 2),
             ..) {
           @Override protected Iterator<IntegernewTargetIterator() {
             return ImmutableList.of(1, 2).iterator();
           }
         };
     assertFailure(tester);
   }
 
   public void testUnknownOrder() {
     new IteratorTester<Integer>(3, newArrayList(1, 2),
       @Override protected Iterator<IntegernewTargetIterator() {
         return newArrayList(2, 1).iterator();
       }
     }.test();
   }
 
   public void testUnknownOrderUnrecognizedElement() {
     IteratorTester<Integertester =
         new IteratorTester<Integer>(3, newArrayList(1, 2, 50),
             ..) {
           @Override protected Iterator<IntegernewTargetIterator() {
             return newArrayList(2, 1, 3).iterator();
           }
         };
     assertFailure(tester);
   }

  
This Iterator wraps another iterator and gives it a bug found in JDK6.

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.

See Sun bug 6529795

  static class IteratorWithSunJavaBug6529795<T> implements Iterator<T> {
    Iterator<T> iterator;
    boolean nextThrewException;
      this. = iterator;
    }
    @Override
    public boolean hasNext() {
      return .hasNext();
    }
    @Override
    public T next() {
      try {
        return .next();
      } catch (NoSuchElementException e) {
         = true;
        throw e;
      }
    }
    @Override
    public void remove() {
      if () {
        throw new IllegalStateException();
      }
      .remove();
    }
  }
    try {
      /* Choose 4 steps to get sequence [next, next, next, remove] */
      new IteratorTester<Integer>(4, newArrayList(1, 2),
          ..) {
        @Override protected Iterator<IntegernewTargetIterator() {
          Iterator<Integeriterator = Lists.newArrayList(1, 2).iterator();
          return new IteratorWithSunJavaBug6529795<Integer>(iterator);
        }
      }.test();
    } catch (AssertionFailedError e) {
      return;
    }
    fail("Should have caught jdk6 bug in target iterator");
  }
    IteratorTester<Integertester =
        new IteratorTester<Integer>(4, newArrayList(1, 2),
            ..) {
          @Override protected Iterator<IntegernewTargetIterator() {
            Iterator<Integeriterator = 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> {
      super(newArrayList(1),
    }
    int numCallsToVerify;
    @Override protected Iterator<IntegernewTargetIterator() {
      return Lists.newArrayList(1).iterator();
    }
    @Override protected void verify(List<Integerelements) {
      ++;
      super.verify(elements);
    }
  }
  public void testVerifyGetsCalled() {
    tester.test();
    assertEquals("Should have verified once per stimulus executed",
        tester.numCallsToVerify,
        tester.numCallsToNewTargetIterator * );
  }
    final String message = "Important info about why verify failed";
    IteratorTester<Integertester =
        new IteratorTester<Integer>(1, newArrayList(1, 2, 3),
            ..) {
          @Override protected Iterator<IntegernewTargetIterator() {
            return Lists.newArrayList(1, 2, 3).iterator();
          }
          @Override protected void verify(List<Integerelements) {
            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<IntegeremptyList = newArrayList();
    IteratorTester<Integertester =
        new IteratorTester<Integer>(1, emptyList,
            ..) {
          @Override protected Iterator<IntegernewTargetIterator() {
            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<Integertester =
        new IteratorTester<Integer>(1, newArrayList(1),
            ..) {
          @Override protected Iterator<IntegernewTargetIterator() {
            return new ThrowingIterator<Integer>(new IllegalStateException());
          }
        };
    assertFailure(tester);
  }
  public void testSimilarException() {
    List<IntegeremptyList = emptyList();
    IteratorTester<Integertester =
        new IteratorTester<Integer>(1, emptyList,
            ..) {
          @Override protected Iterator<IntegernewTargetIterator() {
            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<IntegeremptyList = emptyList();
    IteratorTester<Integertester =
        new IteratorTester<Integer>(1, emptyList,
            ..) {
          @Override protected Iterator<IntegernewTargetIterator() {
            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;
    }
    @Override
    public boolean hasNext() {
      // IteratorTester doesn't expect exceptions for hasNext().
      return true;
    }
    @Override
    public E next() {
      .fillInStackTrace();
      throw ;
    }
    @Override
    public void remove() {
      .fillInStackTrace();
      throw ;
    }
  }
New to GrepCode? Check out our FAQ X