}
    }

    // Call the next interceptor in the chain.
    val next = copy(index = index + 1, request = request)
    val interceptor = interceptors[index]

    @Suppress("USELESS_ELVIS")
    val response =
      interceptor.intercept(next) ?: throw NullPointerException(
        "interceptor $interceptor returned null",
      )

  var eventCount = 0

  private fun onEvent(callEvent: CallEvent) {
    if (eventCount++ == 0) {
      eventRecorder.logEvent(callEvent)
      val next = EventListenerRelay(call, eventRecorder)
      call.addEventListener(next.eventListener)
    }
  }

  private int position;

  /** Returns the element with the specified index. This method is called by {@link #next()}. */
  @ParametricNullness
  protected abstract E get(int index);

  /**
   * Constructs an iterator across a sequence of the given size whose initial position is 0. That
   * is, the first call to {@link #next()} will return the first element (or throw {@link
   * NoSuchElementException} if {@code size} is zero).
   *

    /**
     * Test method for {@link org.codelibs.core.collection.EmptyIterator#next()}.
     */
    @Test
    public void testNext() {
        exception.expect(ClUnsupportedOperationException.class);
        exception.expectMessage(is("next"));
        final EmptyIterator<String> emptyIterator = new EmptyIterator<String>();
        emptyIterator.next();
    }

     */
    boolean enter(@Nonnull Node node);

    /**
     * Ends the visit to the specified dependency node.
     *
     * @param node the dependency node to visit
     * @return <code>true</code> to visit the specified dependency node's next sibling, <code>false</code> to skip the
     *         specified dependency node's next siblings and proceed to its parent
     */

    assertEquals(immutableEntry("foo", 5), entryIterator.next());
    assertEquals(immutableEntry("bar", 4), entryIterator.next());
    assertEquals(immutableEntry("foo", 3), entryIterator.next());
    assertEquals(immutableEntry("cow", 2), entryIterator.next());
    assertEquals(immutableEntry("bar", 1), entryIterator.next());

    Iterator<Entry<String, Collection<Integer>>> collectionIterator =

     */
    @Override
    public boolean hasNext() {
        return false;
    }

    /**
     * {@inheritDoc}
     *
     * @see java.util.Iterator#next()
     */
    @Override
    public SmbResource next() {
        return null;
    }

    /**
     * {@inheritDoc}
     *
     * @see jcifs.CloseableIterator#close()
     */
    @Override

    }

    /**
     * Checks if a next page exists for pagination.
     *
     * @return true if a next page exists, false otherwise
     */
    public boolean isExistNextPage() {
        return existNextPage;
    }

    /**
     * Sets the flag indicating whether a next page exists.
     *
     * @param existNextPage true if a next page exists, false otherwise
     */

    Iterator<?> expectedIter = expected.iterator();
    Iterator<?> actualIter = actual.iterator();

    while (expectedIter.hasNext() && actualIter.hasNext()) {
      if (!equal(expectedIter.next(), actualIter.next())) {
        fail(
            "contents were not equal and in the same order: "
                + "expected = "
                + expected
                + ", actual = "
                + actual);

        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)));
    }