public AbstractTestIterator(String testName) 
{
        super(testName);
}

JUnit constructor.

Parameters:

testName - the test class name

 abstract public Iterator makeEmptyIterator()
Implement this method to return an iterator over an empty collection.

 abstract public Iterator makeFullIterator()
Implement this method to return an iterator over a collection with elements.

 public Object makeObject() 
{
        return makeFullIterator();
}

Implements the abstract superclass method to return the full iterator.

 public boolean supportsEmptyIterator() 
{
        return true;
}

Whether or not we are testing an iterator that can be empty. Default is true.

 public boolean supportsFullIterator() 
{
        return true;
}

Whether or not we are testing an iterator that can contain elements. Default is true.

 public boolean supportsRemove() 
{
        return true;
}

Whether or not we are testing an iterator that supports remove(). Default is true.

 public  void testEmptyIterator() 
{
        if (supportsEmptyIterator() == false) {
            return;
        }
        Iterator it = makeEmptyIterator();
        // hasNext() should return false
        assertEquals("hasNext() should return false for empty iterators", false, it.hasNext());
        // next() should throw a NoSuchElementException
        try {
            it.next();
            fail("NoSuchElementException must be thrown when Iterator is exhausted");
        } catch (NoSuchElementException e) {
        }
        verify();
        assertNotNull(it.toString());
}

Test the empty iterator.

 public  void testFullIterator() 
{
        if (supportsFullIterator() == false) {
            return;
        }
        Iterator it = makeFullIterator();
        // hasNext() must be true (ensure makeFullIterator is correct!)
        assertEquals("hasNext() should return true for at least one element", true, it.hasNext());
        // next() must not throw exception (ensure makeFullIterator is correct!)
        try {
            it.next();
        } catch (NoSuchElementException e) {
            fail("Full iterators must have at least one element");
        }
        // iterate through
        while (it.hasNext()) {
            it.next();
            verify();
        }
        // next() must throw NoSuchElementException now
        try {
            it.next();
            fail("NoSuchElementException must be thrown when Iterator is exhausted");
        } catch (NoSuchElementException e) {
        }
        assertNotNull(it.toString());
}

Test normal iteration behaviour.

 public  void testRemove() 
{
        Iterator it = makeFullIterator();
        if (supportsRemove() == false) {
            // check for UnsupportedOperationException if not supported
            try {
                it.remove();
            } catch (UnsupportedOperationException ex) {}
            return;
        }
        // should throw IllegalStateException before next() called
        try {
            it.remove();
            fail();
        } catch (IllegalStateException ex) {}
        verify();
        // remove after next should be fine
        it.next();
        it.remove();
        // should throw IllegalStateException for second remove()
        try {
            it.remove();
            fail();
        } catch (IllegalStateException ex) {}
}

Test remove behaviour.

 public  void verify() 
{
        // do nothing
}

Allows subclasses to add complex cross verification