emptyIterator.remove();
    }

    /**
     * Test method for
     * {@link org.codelibs.core.collection.EmptyIterator#hasNext()}.
     */
    @Test
    public void testHasNext() {
        final EmptyIterator<String> emptyIterator = new EmptyIterator<String>();
        assertThat(emptyIterator.hasNext(), is(false));
    }

    /**
     * Test method for {@link org.codelibs.core.collection.EmptyIterator#next()}.
     */

        assertThat(it.hasNext(), is(true));
        assertThat(it.next(), is("Foo"));

        assertThat(it.hasNext(), is(true));
        assertThat(it.next(), is("Bar"));

        assertThat(it.hasNext(), is(true));
        assertThat(it.next(), is("Baz"));

        assertThat(it.hasNext(), is(not(true)));
    }

   *
   * <p><b>Note:</b> {@code a.asSet(d).equals(b.asSet(d))} does not imply {@code a.equals(b)}! For
   * example, {@code a} and {@code b} could be {@code [2..4]} and {@code (1..5)}, or the empty
   * ranges {@code [3..3)} and {@code [4..4)}.
   *
   * <p><b>Warning:</b> Be extremely careful what you do with the {@code asSet} view of a large

    Iterator<Subscriber> empty = registry.getSubscribers("");
    assertFalse(empty.hasNext());

    empty = registry.getSubscribers("");

    registry.register(s1);
    assertFalse(empty.hasNext());

    Iterator<Subscriber> one = registry.getSubscribers("");
    assertEquals(s1, one.next().target);
    assertFalse(one.hasNext());

    one = registry.getSubscribers("");

    registry.register(s2);

import static org.codelibs.core.io.LineIterator.iterable;
import static org.hamcrest.CoreMatchers.is;
import static org.hamcrest.CoreMatchers.not;
import static org.junit.Assert.assertThat;

import java.io.StringReader;
import java.util.List;

import org.junit.Test;

/**
 * @author wyukawa
 *
 */
public class IndexedIteratorTest {

    /**
     * @throws Exception

        // Act & Assert: entries a, b, c (dot entries filtered) then end
        assertTrue(it.hasNext());
        assertEquals("a", it.next().getName());
        assertTrue(it.hasNext());
        assertEquals("b", it.next().getName());
        assertTrue(it.hasNext());
        assertEquals("c", it.next().getName());
        assertFalse(it.hasNext());

        // Verify interactions

        vector.add("a");
        final EnumerationIterator<String> itr = new EnumerationIterator<String>(vector.elements());
        assertThat(itr.hasNext(), is(true));
        assertThat(itr.next(), is("a"));
        assertThat(itr.hasNext(), is(not(true)));
    }

    /**
     * @throws Exception
     */
    @Test
    public void testRemove() throws Exception {

    public String toString() {
      return toString;
    }
  }

  Stimulus<E, Iterator<E>> hasNext =
      new Stimulus<E, Iterator<E>>("hasNext") {
        @Override
        void executeAndCompare(ListIterator<E> reference, Iterator<E> target) {
          assertEquals(reference.hasNext(), target.hasNext());
        }
      };
  Stimulus<E, Iterator<E>> next =
      new Stimulus<E, Iterator<E>>("next") {

    @Override
    public void execute(Runnable command) {
      tasks.add(command);
    }

    boolean hasNext() {
      return !tasks.isEmpty();
    }

    void runNext() {
      assertTrue("expected at least one task to run", hasNext());
      tasks.remove().run();
    }

    void runAll() {
      while (hasNext()) {
        runNext();
      }
    }
  }

  private FakeExecutor fakePool;

    public String toString() {
      return toString;
    }
  }

  Stimulus<E, Iterator<E>> hasNext =
      new Stimulus<E, Iterator<E>>("hasNext") {
        @Override
        void executeAndCompare(ListIterator<E> reference, Iterator<E> target) {
          assertEquals(reference.hasNext(), target.hasNext());
        }
      };
  Stimulus<E, Iterator<E>> next =
      new Stimulus<E, Iterator<E>>("next") {