.withFeatures(computeElementSetFeatures(parentBuilder.getFeatures()))
        .suppressing(parentBuilder.getSuppressedTests())
        .createTestSuite();
  }

  /**
   * To avoid infinite recursion, test suites with these marker features won't have derived suites
   * created for them.
   */
  enum NoRecurse implements Feature<Void> {
    SUBMULTISET,
    DESCENDING;

    @Override

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

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

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{

Você pode se inscrever (pouco frequente) [**FastAPI e amigos** newsletter](newsletter.md){.internal-link target=_blank} para receber atualizações:

* Notícias sobre FastAPI e amigos 🚀
* Tutoriais 📝
* Recursos ✨
* Mudanças de última hora 🚨
* Truques e dicas ✅

## Siga o FastAPI no X (Twitter)

    private final int filter;
    private final boolean recursive;

    /**
     * @param fh
     * @param filter
     * @param recursive
     *
     */
    public SmbWatchHandleImpl(final SmbFileHandleImpl fh, final int filter, final boolean recursive) {
        this.handle = fh;
        this.filter = filter;
        this.recursive = recursive;
    }

    /**
     * {@inheritDoc}
     *

                }
            }
        }

        final Object recursive = dataMap.remove(getParamValue(paramMap, "field.recursive", "recursive"));
        if (recursive == null || Constants.FALSE.equalsIgnoreCase(recursive.toString())) {
            return 1L;
        }
        if (Constants.TRUE.equalsIgnoreCase(recursive.toString())) {
            return -1L;
        }

        return 1L;
    }

			ID:           mustGetUUID(),
			Bucket:       "",
			BaseDir:      pathNames[i%paths],
			Prefix:       "",
			FilterPrefix: "",
			Marker:       "",
			Limit:        0,
			AskDisks:     "strict",
			Recursive:    false,
			Separator:    slashSeparator,
			Create:       true,
		})
	}
	b.ReportAllocs()

	for i := 0; b.Loop(); i++ {
		bm.findCache(listPathOptions{
			ID:           mustGetUUID(),

// newMetacache constructs a new metacache from the options.
func (o listPathOptions) newMetacache() metacache {
	return metacache{
		id:          o.ID,
		bucket:      o.Bucket,
		root:        o.BaseDir,
		recursive:   o.Recursive,
		status:      scanStateStarted,
		error:       "",
		started:     UTCNow(),
		lastHandout: UTCNow(),
		lastUpdate:  UTCNow(),
		ended:       time.Time{},
		dataVersion: metacacheStreamVersion,

		t.Fatal(err)
	}

	if fileInfoPreHeal.NumVersions != 1 {
		t.Fatalf("Expected versions 1, got %d", fileInfoPreHeal.NumVersions)
	}

	if err = objLayer.HealObjects(ctx, bucket, "", madmin.HealOpts{Recursive: true, Remove: true},
		func(bucket, object, vid string, scanMode madmin.HealScanMode) error {
			_, err := objLayer.HealObject(ctx, bucket, object, vid, madmin.HealOpts{ScanMode: scanMode, Remove: true})
			return err

    }

    // Parameterized test to exercise SMB2 with different recursive and filter values
    @ParameterizedTest(name = "SMB2 param: recursive={0}, filter={1}")
    @CsvSource({ "true, 0", "false, -1" })
    @DisplayName("watch() SMB2 parameterized branches execute without error")
    void watch_smb2_parameterized(boolean recursive, int filter) throws Exception {
        NotifyResponse resp = mock(NotifyResponse.class);