the new API. This helps with our end-of-cycle audit of new APIs.
The same requirement applies to next/* (described below), which will
become a go1.XX.txt for XX >= 19.

The next/ directory contains the only files intended to be mutated.
Each file in that directory contains a list of features that may be added
to the next release of Go. The files in this directory only affect the
warning output from the go api tool. Each file should be named

	return len(in.ifdefStack) == 0 || in.ifdefStack[len(in.ifdefStack)-1]
}

func (in *Input) expectNewline(directive string) {
	tok := in.Stack.Next()
	if tok != '\n' {
		in.expectText("expected newline after", directive)
	}
}

func (in *Input) Next() ScanToken {
	if in.peek {
		in.peek = false
		tok := in.peekToken
		in.text = in.peekText
		return tok
	}

    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,

    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(

        if (element == null) {
            for (Entry e = header.next; e != header; e = e.next) {
                if (e.element == null) {
                    e.remove();
                    return true;
                }
            }
        } else {
            for (Entry e = header.next; e != header; e = e.next) {
                if (element.equals(e.element)) {
                    e.remove();

	}
	tok = p.next()
	if tok.ScanToken == '+' {
		if p.next().ScanToken != scanner.Int {
			return "", obj.ABI0, false
		}
		tok = p.next()
	}
	if tok.ScanToken != '(' {
		return "", obj.ABI0, false
	}
	if reg := p.next(); reg.ScanToken != scanner.Ident || reg.String() != "SB" {
		return "", obj.ABI0, false
	}
	if p.next().ScanToken != ')' || p.peek() != scanner.EOF {

        }
    }

    private void parseHtmlEntity(StringBuilder buffer) {
        scanner.next();
        scanner.mark();
        scanner.find(';');
        String value = ENTITIES.get(scanner.region().toLowerCase(Locale.ROOT));
        buffer.append(value);
        scanner.next();
    }

    private void parseHtmlEncodedChar(StringBuilder buffer) {
        scanner.next(2);
        scanner.mark();

    assertThrows(NoSuchElementException.class, () -> iterator.next());
    assertThrows(IllegalStateException.class, () -> iterable.iterator());
  }

  public void testOf_one() {
    Iterable<String> iterable = MinimalIterable.of("a");
    Iterator<String> iterator = iterable.iterator();
    assertTrue(iterator.hasNext());
    assertEquals("a", iterator.next());
    assertFalse(iterator.hasNext());

    assertTrue(iterator.hasNext());
    assertEquals("a", iterator.next());
    assertThrows(UnsupportedOperationException.class, () -> iterator.remove());
  }

  @SuppressWarnings("DoNotCall")
  public void testAdd() {
    ListIterator<String> iterator = create();

    assertTrue(iterator.hasNext());
    assertEquals("a", iterator.next());
    assertEquals("b", iterator.next());
    assertEquals("b", iterator.previous());

        throw new IllegalStateException();
      }
      iterator.remove();
    }
  }

  public void testCanCatchSunJavaBug6529795InTargetIterator() {
    try {
      /* Choose 4 steps to get sequence [next, next, next, remove] */
      new IteratorTester<Integer>(
          4, MODIFIABLE, newArrayList(1, 2), IteratorTester.KnownOrder.KNOWN_ORDER) {
        @Override
        protected Iterator<Integer> newTargetIterator() {