assertTrue(verifySource.exists(), "Source file should exist");

        // Move file using copy and delete
        CIFSContext moveContext = createFreshContext();
        String targetFileName = "movedir_" + timestamp + "/moved_" + timestamp + ".txt";
        SmbFile srcForCopy = new SmbFile(baseUrl + "shared/" + sourceFileName, moveContext);
        SmbFile targetFile = new SmbFile(baseUrl + "shared/" + targetFileName, moveContext);

		mode |= fs.ModeDir
	}
	return mode
}

// SetMode changes the permission and mode bits for the [FileHeader].
func (h *FileHeader) SetMode(mode fs.FileMode) {
	h.CreatorVersion = h.CreatorVersion&0xff | creatorUnix<<8
	h.ExternalAttrs = fileModeToUnixMode(mode) << 16

	// set MSDOS attributes too, as the original zip does.
	if mode&fs.ModeDir != 0 {
		h.ExternalAttrs |= msdosDir
	}

		{name: "dir1/dira/dirasub/sublevel3/dccccfile", size: 10},
	}
	createUsageTestFiles(t, base, bucket, files)

	getSize := func(item scannerItem) (sizeS sizeSummary, err error) {
		if item.Typ&os.ModeDir == 0 {
			var s os.FileInfo
			s, err = os.Stat(item.Path)
			if err != nil {
				return sizeS, err
			}
			sizeS.totalSize = s.Size()
			sizeS.versions++
			return sizeS, nil
		}
		return sizeS, err

			Mode: wt.Mode,
		}
	}
	return fsys
}

func TestWriterAddFS(t *testing.T) {
	buf := new(bytes.Buffer)
	w := NewWriter(buf)
	tests := []WriteTest{
		{Name: "emptyfolder", Mode: 0o755 | os.ModeDir},
		{Name: "file.go", Data: []byte("hello"), Mode: 0644},
		{Name: "subfolder/another.go", Data: []byte("world"), Mode: 0644},
		// Notably missing here is the "subfolder" directory. This makes sure even

				return err
			}

			if fi.IsDir() {
				// Ignore symlinked directories.
				continue
			}

			typ = fi.Mode()
		case data.FileAttributes&syscall.FILE_ATTRIBUTE_DIRECTORY != 0:
			typ = os.ModeDir
		}

		if err = filter(name, typ); err == errDoneForNow {
			// filtering requested to return by caller.
			return nil
		}
	}

	return nil
}

			t.Fatalf("test %d, String() = %q, want %q", i, got, wantStr)
		}
	}
}

func TestWriterAddFS(t *testing.T) {
	fsys := fstest.MapFS{
		"emptyfolder":          {Mode: 0o755 | os.ModeDir},
		"file.go":              {Data: []byte("hello")},
		"subfolder/another.go": {Data: []byte("world")},
		"symlink.go":           {Mode: 0o777 | os.ModeSymlink, Data: []byte("file.go")},

	if direntInode(dirent) == 0 { // File absent in directory.
		return consumed, name, typ, err
	}
	switch dirent.Type {
	case syscall.DT_REG:
		typ = 0
	case syscall.DT_DIR:
		typ = os.ModeDir
	case syscall.DT_LNK:
		typ = os.ModeSymlink
	default:
		// Skip all other file types. Revisit if/when this code needs
		// to handle such files, MinIO is only interested in
		// files and directories.

}

func (m *minioFileInfo) Name() string {
	return m.p
}

func (m *minioFileInfo) Size() int64 {
	return m.info.Size
}

func (m *minioFileInfo) Mode() os.FileMode {
	if m.isDir {
		return os.ModeDir
	}
	return os.ModePerm
}

var minFileDate = time.Date(1980, 1, 1, 0, 0, 0, 0, time.UTC) // Workaround for Filezilla

func (m *minioFileInfo) ModTime() time.Time {
	if !m.info.LastModified.IsZero() {

				Content:  []byte{},
				Mode:     fs.ModeDir | 0666,
				Modified: time.Date(2021, 12, 29, 0, 0, 0, 0, timeZone(0)),
			},
			{
				Name:     "a/b",
				Content:  []byte{},
				Mode:     0666,
				Modified: time.Date(2021, 12, 29, 0, 0, 0, 0, timeZone(0)),
			},
			{
				Name:     "a/b/",
				Content:  []byte{},
				Mode:     fs.ModeDir | 0666,

// If versioned the latest version will be returned.
func (e *metaCacheEntry) fileInfo(bucket string) (FileInfo, error) {
	if e.isDir() {
		return FileInfo{
			Volume: bucket,
			Name:   e.name,
			Mode:   uint32(os.ModeDir),
		}, nil
	}
	if e.cached != nil {
		if len(e.cached.versions) == 0 {
			// This special case is needed to handle xlMeta.versions == 0
			return FileInfo{
				Volume:   bucket,
				Name:     e.name,