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;
    }

// 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,

			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(),

     * @param in the input stream to validate
     * @param recursive whether to recursively check compressed files
     * @return true if the stream contains valid sitemap data, false otherwise
     */
    protected boolean isValid(final InputStream in, final boolean recursive) {
        final BufferedInputStream bis = new BufferedInputStream(in);
        bis.mark(preloadSize);

    }

    // 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);

		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

				return err
			}
		}

		return nil
	}

	prefix = retainSlash(prefix)

	for object := range clnt.ListObjects(cctx, bucket, minio.ListObjectsOptions{
		Prefix:    prefix,
		Recursive: false,
	}) {
		if object.Err != nil {
			return object.Err
		}

		if object.Key == prefix {
			continue
		}

		isDir := strings.HasSuffix(object.Key, SlashSeparator)

	lopts := listPathRawOptions{
		disks:          disks,
		bucket:         bucket,
		path:           path,
		filterPrefix:   filterPrefix,
		recursive:      recursive,
		forwardTo:      "",
		minDisks:       1,
		reportNotFound: false,
		agreed: func(entry metaCacheEntry) {
			if !recursive && prefix != entry.name {
				return
			}
			if err := healEntry(bucket, entry, scanMode); err != nil {
				cancel()
			}
		},

    }

    // --- as(Class, DLSequence, int) ---

    @Test
    void testAs_DLSequence_RecursiveBug() {
        // This test exposes a recursive bug in the current implementation
        // The method calls itself, leading to a StackOverflowError.
        ASN1EncodableVector vector = new ASN1EncodableVector();
        vector.add(new ASN1Integer(10));