if err != nil {
		return consumed, nil, typ, err
	}

	return consumed, nameBuf[:nameLen], typ, nil
}

// readDirFn applies the fn() function on each entries at dirPath, doesn't recurse into
// the directory itself, if the dirPath doesn't exist this function doesn't return
// an error.
func readDirFn(dirPath string, fn func(name string, typ os.FileMode) error) error {

func (d *Decoder) Pos() int { return int(d.pos) }

// Err returns the most recent decoder error if any, or nil
func (d *Decoder) Err() error { return d.err }

// MaxDepth will set the maximum recursion depth.
// If the maximum depth is exceeded, ErrMaxDepth is returned.
// Less than or 0 means no limit (default).
func (d *Decoder) MaxDepth(n int) *Decoder {
	d.maxDepth = n
	return d
}

    @Override
    public <T> T[] toArray(T[] array) {
      return snapshot().toArray(array);
    }

    /*
     * We'd love to use 'new ArrayList(this)' or 'list.addAll(this)', but
     * either of these would recurse back to us again!
     */
    private List<E> snapshot() {
      List<E> list = newArrayListWithExpectedSize(size());
      for (Multiset.Entry<E> entry : entrySet()) {
        E element = entry.getElement();

    return getMethod(ListSubListTester.class, "testSubList_subListRemoveAffectsOriginalLargeList");
  }

  /*
   * TODO: perform all List tests on subList(), but beware infinite recursion
   */

    return getMethod(ListSubListTester.class, "testSubList_subListRemoveAffectsOriginalLargeList");
  }

  /*
   * TODO: perform all List tests on subList(), but beware infinite recursion
   */

   * provided null elements.
   */
  public Joiner skipNulls() {
    return new Joiner(this) {
      @Override
      @SuppressWarnings("JoinIterableIterator") // suggests infinite recursion
      public String join(Iterable<?> parts) {
        return join(parts.iterator());
      }

      @Override
      public <A extends Appendable> A appendTo(A appendable, Iterator<?> parts) throws IOException {

    static final NonPublicConstantIgnored INSTANCE = new NonPublicConstantIgnored();

    private NonPublicConstantIgnored() {}
  }

  public static class NonStaticFieldIgnored {
    // This should cause infinite recursion. But it shouldn't be used anyway.
    public final NonStaticFieldIgnored instance = new NonStaticFieldIgnored();

    private NonStaticFieldIgnored() {}
  }

func (b *Reader) Reset(r io.Reader) {
	// If a Reader r is passed to NewReader, NewReader will return r.
	// Different layers of code may do that, and then later pass r
	// to Reset. Avoid infinite recursion in that case.
	if b == r {
		return
	}
	if b.buf == nil {
		b.buf = make([]byte, defaultBufSize)
	}
	b.reset(b.buf, r)
}

func (b *Reader) reset(buf []byte, r io.Reader) {
	*b = Reader{

    }

    @Test
    public void test_defaultMaxGroupDepth() {
        EntraIdAuthenticator authenticator = new EntraIdAuthenticator();

        // Test that default max depth (10) prevents deep recursion
        // Depth 100 should exceed default and return empty
        Pair<String[], String[]> result = authenticator.getParentGroup(null, "test-id", 100);
        assertNotNull(result);

    String nodeString = graphString.substring(nodeStart, edgeStart);

    Network<N, EndpointPair<N>> asNetwork = graph.asNetwork();
    // Don't call AbstractNetworkTest.validateNetwork(asNetwork).  Mutual recursion.
    assertThat(graph.nodes()).isEqualTo(asNetwork.nodes());
    assertThat(graph.edges()).hasSize(asNetwork.edges().size());
    assertThat(graph.nodeOrder()).isEqualTo(asNetwork.nodeOrder());