{name: "rootfile2", size: 10000},
		{name: "dir1/d1file", size: 2000},
		{name: "dir2/d2file", size: 300},
		{name: "dir2/d2file2", size: 300},
		{name: "dir2/d2file3/", size: 300},
		{name: "dir2/d2file4/", size: 300},
		{name: "dir2/d2file5", size: 300},
		{name: "dir1/dira/dafile", size: 100000},
		{name: "dir1/dira/dbfile", size: 200000},
		{name: "dir1/dira/dirasub/dcfile", size: 1000000},

# Textmate
# --------
.textmate

# Sublime Text
# ------------
*.sublime-*

# jEnv
# ----
.java-version

# macOS
# ----
.DS_Store

# HPROF
# -----
*.hprof

# Work dirs
# ---------
/incoming-distributions
/intTestHomeDir

# Logs
# ----
/*.log

# Thread dumps for troubleshooting
*.threaddump
# ps output for cleaning up leaking Java processes
*.psoutput

				r.fileList[idx].isDup = true
				continue
			}
			if idx, ok := knownDirs[name]; ok {
				r.fileList[idx].isDup = true
				continue
			}

			for dir := path.Dir(name); dir != "."; dir = path.Dir(dir) {
				dirs[dir] = true
			}

			idx := len(r.fileList)
			entry := fileListEntry{
				name:  name,
				file:  file,
				isDir: isDir,
			}
			r.fileList = append(r.fileList, entry)

// Special test type for test with directories
type objTestTypeWithDirs func(obj ObjectLayer, instanceType string, dirs []string, t TestErrHandler)

// Special object test type for disk not found situations.
type objTestDiskNotFoundType func(obj ObjectLayer, instanceType string, dirs []string, t *testing.T)

// ExecObjectLayerTest - executes object layer tests.

		t.Fatal("Unable to initialize 'Erasure' object layer.", err)
	}
	// Remove all dirs.
	for _, dir := range fsDirs {
		defer os.RemoveAll(dir)
	}

	type testCaseType struct {
		bucket string
		object string
	}

	bucketName := "bucket"
	testCases := []testCaseType{
		{bucketName, "dir/obj1"},
		{bucketName, "dir/obj1"},
	}

	err = obj.MakeBucket(ctx, bucketName, MakeBucketOptions{

		return nil
	}

	// Delete excessive inline entries.
	// Convert to slice.
	dirs = dirs[:0]
	for dir := range foundDirs {
		dirs = append(dirs, dir)
	}
	if xl.data.remove(dirs...) {
		newBuf, err := xl.AppendTo(metaDataPoolGet())
		if err == nil {
			defer metaDataPoolPut(newBuf)
			return s.WriteAll(ctx, volume, pathJoin(path, xlStorageFormatFile), buf)
		}
	}
	return nil

	for i, testCase := range testCases {
		dir := t.TempDir()

		for c := 1; c <= testCase.numFiles; c++ {
			err := os.WriteFile(filepath.Join(dir, fmt.Sprintf("%d", c)), []byte{}, os.ModePerm)
			if err != nil {
				os.RemoveAll(dir)
				t.Fatalf("Unable to create a file, %s", err)
			}
		}
		entries, err := readDirN(dir, testCase.n)
		if err != nil {
			os.RemoveAll(dir)
			t.Fatalf("Unable to read entries, %s", err)

				result.After.Drives[i].State = madmin.DriveStateOk
			}
		}
	}

	return result, nil
}

// checkAbandonedParts will check if an object has abandoned parts,
// meaning data-dirs or inlined data that are no longer referenced by the xl.meta
// Errors are generally ignored by this function.

	}
	return prefer, true
}

// isInDir returns whether the entry is in the dir when considering the separator.
func (e metaCacheEntry) isInDir(dir, separator string) bool {
	if len(dir) == 0 {
		// Root
		idx := strings.Index(e.name, separator)
		return idx == -1 || idx == len(e.name)-len(separator)
	}
	ext := strings.TrimPrefix(e.name, dir)
	if len(ext) != len(e.name) {
		idx := strings.Index(ext, separator)

}

// testPostPolicyReservedBucketExploit is a test for the exploit fixed in PR
// #16849
func testPostPolicyReservedBucketExploit(obj ObjectLayer, instanceType string, dirs []string, t TestErrHandler) {
	if err := newTestConfig(globalMinioDefaultRegion, obj); err != nil {
		t.Fatalf("Initializing config.json failed")
	}

	// Register the API end points with Erasure/FS object layer.