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

type Token struct {
	ScanToken
	text string
}

// Make returns a Token with the given rune (ScanToken) and text representation.
func Make(token ScanToken, text string) Token {
	// Substitute the substitutes for . and /.
	text = strings.ReplaceAll(text, "\u00B7", ".")
	text = strings.ReplaceAll(text, "\u2215", "/")
	return Token{ScanToken: token, text: text}
}

func (l Token) String() string {

        }
    }

    @Test
    @DisplayName("Constructor with andx sets next command")
    void testConstructorWithAndx() {
        DummyPlainSMB next = new DummyPlainSMB();
        DummyAndXBlock block = new DummyAndXBlock(next);

        assertNotNull(block);
        assertSame(next, block.andx, "andx should reference provided SMB");
    }

    @Test

	return &Reader{r: r, curr: &regFileReader{r, 0}}
}

// Next advances to the next entry in the tar archive.
// The Header.Size determines how many bytes can be read for the next file.
// Any remaining data in the current file is automatically discarded.
// At the end of the archive, Next returns the error io.EOF.
//
// If Next encounters a non-local name (as defined by [filepath.IsLocal])

    Iterator<Entry<E>> entryIterator = entryIterator();
    return entryIterator.hasNext() ? entryIterator.next() : null;
  }

  @Override
  public @Nullable Entry<E> lastEntry() {
    Iterator<Entry<E>> entryIterator = descendingEntryIterator();
    return entryIterator.hasNext() ? entryIterator.next() : null;
  }

  @Override
  public @Nullable Entry<E> pollFirstEntry() {

        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) {

            n.clearFlags(SMB2_FLAGS_RELATED_OPERATIONS);
        }
        return n;
    }

    /**
     * Sets the next request in the compound chain.
     *
     * @param next the next request
     */
    public void setNext(final ServerMessageBlock2Request<?> next) {
        super.setNext(next);
    }

    /**
     * {@inheritDoc}
     *
     * @see jcifs.util.transport.Request#getCreditCost()
     */

     */
    CommonServerMessageBlockRequest createCancel();

    /**
     * Checks if chaining is allowed with the next request.
     *
     * @param next the next request in the chain
     * @return whether to allow chaining
     */
    boolean allowChain(CommonServerMessageBlockRequest next);

    /**
     * Sets the tree ID.
     *
     * @param t the tree ID to set
     */
    void setTid(int t);

        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

   * part of the smeared hash of the key 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>
   *