final int nexts = str.indexOf('[', si + 1);
                        final int nexte = str.indexOf(']', si);
                        if (nexts >= 0 && nexte >= 0 && nexte == nexts - 1) {
                            server = str.substring(si, nexte + 1);
                            si = nexts;
                        } else {
                            server = "127.0.0.1";

        // Given
        Trans2FindNext2 next = new Trans2FindNext2(0x0101, 0, "name");
        byte[] buf = new byte[16];

        // When/Then
        assertEquals(0, next.readSetupWireFormat(buf, 0, buf.length));
        assertEquals(0, next.readParametersWireFormat(buf, 0, buf.length));
        assertEquals(0, next.readDataWireFormat(buf, 0, buf.length));
        assertEquals(0, next.writeDataWireFormat(buf, 0));
    }

                assertFalse(iterator3.hasNext(), "Third instance should have no elements");

                assertNull(iterator1.next(), "First instance next() should return null");
                assertNull(iterator2.next(), "Second instance next() should return null");
                assertNull(iterator3.next(), "Third instance next() should return null");
            } catch (CIFSException e) {
                throw new RuntimeException(e);
            }

        SmbResource result = iterator.next();
        assertNotNull(result, "Should still be able to get element");
        assertEquals("file1.txt", result.getName());

        assertFalse(iterator.hasNext(), "Should not have more elements");

        // Verify delegate.next() was only called once
        verify(mockDelegate, times(1)).next();
    }

    /**

     */
    @Override
    public boolean hasNext() {
        return this.next != null;
    }

    /**
     * {@inheritDoc}
     *
     * @see java.util.Iterator#next()
     */
    @Override
    public FileEntry next() {
        final FileEntry n = this.next;
        try {
            final FileEntry ne = advance(false);
            if (ne == null) {

     */
    @Override
    public boolean hasNext() {
        return this.next != null;
    }

    /**
     * {@inheritDoc}
     *
     * @see java.util.Iterator#next()
     */
    @Override
    public FileEntry next() {
        final FileEntry n = this.next;
        try {
            final FileEntry ne = advance();
            if (ne == null) {

     */
    @Override
    public boolean hasNext() {
        return this.next != null;
    }

    /**
     * {@inheritDoc}
     *
     * @see java.util.Iterator#next()
     */
    @Override
    public SmbResource next() {
        final SmbResource n = this.next;
        this.next = advance();
        return n;
    }

    /**
     * {@inheritDoc}
     *

    public long expiration;

    /** The next DFS referral in the chain */
    DfsReferral next;
    /** Map containing DFS referral entries */
    Map map;
    /** The cache key for this referral */
    String key = null;

    /**
     * Constructs a new DfsReferral instance
     */
    public DfsReferral() {
        this.next = this;
    }

    void append(final DfsReferral dr) {

                    }

                    DfsReferralDataInternal next = dr;
                    do {
                        next.stripPathConsumed(1 + domain.length() + 1 + root.length());
                        next = next.next();
                    } while (next != dr);

                    if (dr.getPathConsumed() > (path != null ? path.length() : 0)) {

        when(delegate.hasNext()).thenReturn(true, true, false);
        when(delegate.next()).thenReturn(bad, good);

        NetServerFileEntryAdapterIterator itr = new NetServerFileEntryAdapterIterator(parent, delegate, null);

        // Act: first valid next should be the second element
        assertTrue(itr.hasNext());
        SmbResource r = itr.next();

        // Assert: the invalid name was skipped, valid one returned