var unionWith: Mapping = mapping
    index++

    while (index < mappings.size) {
      val next = mappings[index]

      if (type != canonicalizeType(next.type)) break
      if (type == TYPE_MAPPED && mappedTo != next.mappedTo) break

      unionWith = next
      index++
    }

    result +=
      Mapping(
        sourceCodePoint0 = mapping.sourceCodePoint0,

        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

	s.tr = append(s.tr, tr)
}

func (s *Stack) Next() ScanToken {
	tos := s.tr[len(s.tr)-1]
	tok := tos.Next()
	for tok == scanner.EOF && len(s.tr) > 1 {
		tos.Close()
		// Pop the topmost item from the stack and resume with the next one down.
		s.tr = s.tr[:len(s.tr)-1]
		tok = s.Next()
	}
	return tok
}

func (s *Stack) Text() string {
	return s.tr[len(s.tr)-1].Text()
}

func (s *Stack) File() string {

    int next = table[tableIndex];
    if (next == UNSET) {
      table[tableIndex] = newEntryIndex;
    } else {
      int last;
      long entry;
      do {
        last = next;
        entry = entries[next];
        if (getHash(entry) == hash && Objects.equals(key, keys[next])) {
          int oldValue = values[next];

          values[next] = value;
          return oldValue;

   * guaranteed to be equal to each other.
   */
  @CanIgnoreReturnValue
  @Override
  @ParametricNullness
  E next();

  /**
   * {@inheritDoc}
   *
   * <p>Implementations may or may not support removal when a call to {@link #peek()} has occurred
   * since the most recent call to {@link #next()}.
   *

        }
    }

    @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

		if s.Peek() == '>' {
			s.Next()
			t.tok = ARR
			return ARR
		}
	case '@':
		if s.Peek() == '>' {
			s.Next()
			t.tok = ROT
			return ROT
		}
	case '<':
		if s.Peek() == '<' {
			s.Next()
			t.tok = LSH
			return LSH
		}
	case '>':
		if s.Peek() == '>' {
			s.Next()
			t.tok = RSH
			return RSH
		}
	}
	return t.tok
}

    assertEquals(
        "next() should still return first element after peeking", "A", peekingIterator.next());

    assertEquals("Should be able to peek() at middle element", "B", peekingIterator.peek());
    assertEquals(
        "Should be able to peek() middle element multiple times", "B", peekingIterator.peek());
    assertEquals(

    }

    /**
     * Checks if a next page exists.
     *
     * @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, false otherwise
     */

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 {