return next != null;
    }

    @Override
    @ParametricNullness
    public K next() {
      checkForConcurrentModification();
      if (next == null) {
        throw new NoSuchElementException();
      }
      current = next;
      seenKeys.add(current.getKey());
      do { // skip ahead to next unseen key
        next = next.next;

        FileEntry entry3 = mock(FileEntry.class);

        // Constructor gets entry1, first next() returns it and gets entry2,
        // second next() returns entry2 and gets entry3,
        // third next() returns entry3 and exhausts
        when(delegate.hasNext()).thenReturn(true, true, true, false);
        when(delegate.next()).thenReturn(entry1, entry2, entry3);

        TestIterator iterator = new TestIterator(null);

     */
    public boolean chain(final ServerMessageBlock2 n) {
        if (this.next != null) {
            return this.next.chain(n);
        }

        n.addFlags(SMB2_FLAGS_RELATED_OPERATIONS);
        this.next = n;
        return true;
    }

    /**
     * Gets the next message in the compound chain.
     *
     * @return the next message or null if this is the last message
     */

   */
  public abstract @Nullable C previous(C value);

  /**
   * Returns a signed value indicating how many nested invocations of {@link #next} (if positive) or
   * {@link #previous} (if negative) are needed to reach {@code end} starting from {@code start}.
   * For example, if {@code end = next(next(next(start)))}, then {@code distance(start, end) == 3}
   * and {@code distance(end, start) == -3}. As well, {@code distance(a, a)} is always zero.
   *

   * part of the smeared hash of the element not covered by the hashtable mask, whereas the low bits
   * are the "next" pointer (pointing to the next entry in the bucket chain), which will always be
   * less than or equal to the hashtable mask.
   *
   * <pre>
   * hash  = aaaaaaaa
   * mask  = 00000fff
   * next  = 00000bbb
   * entry = aaaaabbb
   * </pre>
   *

  @SuppressWarnings("GoodTime") // b/122668874
  void setAccessTime(long time);

  /** Returns the next entry in the access queue. */
  ReferenceEntry<K, V> getNextInAccessQueue();

  /** Sets the next entry in the access queue. */
  void setNextInAccessQueue(ReferenceEntry<K, V> next);

  /** Returns the previous entry in the access queue. */
  ReferenceEntry<K, V> getPreviousInAccessQueue();

    }

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

    /**
     * Sets the flag for the existence of a next page.
     *
     * @param existNextPage true if a next page exists.
     */

        this.existPrePage = existPrePage;
    }

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

    /**
     * Sets whether a next page exists.
     * @param existNextPage true if next page exists
     */
    public void setExistNextPage(final boolean existNextPage) {

        final LineIterator it = new LineIterator(reader);
        assertThat(it.hasNext(), is(true));
        assertThat(it.next(), is("aaa"));
        assertThat(it.hasNext(), is(true));
        assertThat(it.next(), is("bbb"));
        assertThat(it.hasNext(), is(true));
        assertThat(it.next(), is("ccc"));
        assertThat(it.hasNext(), is(not(true)));
    }

    /**
     * @throws Exception
     */
    @Test

    final Runnable runnable;
    final Executor executor;
    @Nullable RunnableExecutorPair next;

    RunnableExecutorPair(
        Runnable runnable, Executor executor, @Nullable RunnableExecutorPair next) {
      this.runnable = runnable;
      this.executor = executor;
      this.next = next;
    }
  }