line   int
	pos    int
}

func NewSlice(base *src.PosBase, line int, tokens []Token) *Slice {
	return &Slice{
		tokens: tokens,
		base:   base,
		line:   line,
		pos:    -1, // Next will advance to zero.
	}
}

func (s *Slice) Next() ScanToken {
	s.pos++
	if s.pos >= len(s.tokens) {
		return scanner.EOF
	}
	return s.tokens[s.pos].ScanToken
}

func (s *Slice) Text() string {

            if (info != null) {
                interfaces.add(info);
            }

            if (next == 0) {
                // Last entry - advance by the full structure size
                bufferIndex += 152;
                break;
            }

            // Move to next entry based on Next offset
            bufferIndex += next;
        }

     */
    @Execute
    public HtmlResponse index(final SearchForm form) {
        return search(form);
    }

    /**
     * The advance search page.
     * @param form The search form.
     * @return The HTML response.
     */
    @Execute
    public HtmlResponse advance(final SearchForm form) {
        if (isLoginRequired()) {
            return redirectToLogin();
        }

import jcifs.SmbResource;

/**
 * Tests for {@link DirFileEntryAdapterIterator}.
 *
 * This test class verifies the basic functionality of DirFileEntryAdapterIterator.
 * Due to the iterator's constructor calling advance() immediately, which requires
 * the adapt() method to be functional, we test the behavior using simple mock
 * scenarios that don't require complex filter setups.
 */
@ExtendWith(MockitoExtension.class)

      return;
    }
    int oldSize = map.size();
    if (map.size() < 2 || !supportsClear) {
      return;
    }
    Iterator<Entry<K, V>> iterator = map.entrySet().iterator();
    iterator.next(); // advance
    Entry<K, V> secondEntry = iterator.next();
    K key = secondEntry.getKey();
    SortedMap<K, V> subMap = map.tailMap(key);
    int subMapSize = subMap.size();
    subMap.clear();

      return;
    }
    int oldSize = map.size();
    if (map.size() < 2 || !supportsClear) {
      return;
    }
    Iterator<Entry<K, V>> iterator = map.entrySet().iterator();
    iterator.next(); // advance
    Entry<K, V> secondEntry = iterator.next();
    K key = secondEntry.getKey();
    SortedMap<K, V> subMap = map.tailMap(key);
    int subMapSize = subMap.size();
    subMap.clear();

    }

    @Override
    public void encode(final NdrBuffer buf) throws NdrException {
        final int start = buf.getIndex();
        int alloc_hint_index = 0;

        buf.advance(16); /* momentarily skip header */
        if (this.ptype == 0) { /* Request */
            alloc_hint_index = buf.getIndex();
            buf.enc_ndr_long(0); /* momentarily skip alloc hint */

        assertNotNull(next);
        assertEquals("good", next.getName());
        assertFalse(it.hasNext());
        verify(tree, times(1)).release();
    }

    @Test
    @DisplayName("advance() path handles fetchMore throwing CIFSException in next()")
    void advanceFetchMoreThrows() throws Exception {
        // Arrange
        stubAcquireReturnsSelf();

        assertTrue(
                later.minus(initial).toMillis() >= 45,
                "Elapsed time difference should be at least 45ms (accounting for some timing variance)");
    }

    @Test
    @DisplayName("MonotonicClock start time should remain constant")
    void testStartTime() throws InterruptedException {
        Instant start1 = MonotonicClock.start();

                doClose();
                return null;
            }
            throw e;
        }

        this.response.setSubCommand(SmbComTransaction.TRANS2_FIND_NEXT2);
        final FileEntry n = advance(false);
        if (n == null) {
            doClose();
        }
        return n;
    }

    /**
     * {@inheritDoc}
     *
     * @see jcifs.smb.DirFileEntryEnumIteratorBase#getResults()
     */