pkg os, method (*Root) ReadFile(string) ([]uint8, error) #73126
pkg os, method (*Root) Readlink(string) (string, error) #67002
pkg os, method (*Root) RemoveAll(string) error #67002
pkg os, method (*Root) Rename(string, string) error #67002
pkg os, method (*Root) Symlink(string, string) error #67002
pkg os, method (*Root) WriteFile(string, []uint8, fs.FileMode) error #73126

				if isReservedOrInvalidBucket(volInfo.Name, false) {
					continue
				}

				healBuckets.Compute(volInfo.Name, func(oldValue VolInfo, loaded bool) (newValue VolInfo, del bool) {
					if loaded {
						newValue = oldValue
						newValue.count = oldValue.count + 1
						return newValue, false
					}
					return VolInfo{
						Name:    volInfo.Name,
						Created: volInfo.Created,
						count:   1,

	}

	fields := []*schema.Field{
		{Name: "ID", DBName: "id", BindNames: []string{"ID"}, DataType: schema.Uint, PrimaryKey: true, Size: 64, Creatable: true, Updatable: true, Readable: true, HasDefaultValue: true, AutoIncrement: true},
		{Name: "Name", DBName: "", BindNames: []string{"Name"}, DataType: "", Tag: `gorm:"-"`, Creatable: false, Updatable: false, Readable: false},

        void testRenameToSameFile() throws MalformedURLException, SmbException {
            // Arrange
            doThrow(new SmbException("Cannot rename to same file")).when(smbFile).renameTo(smbFile);

            // Act & Assert
            assertThrows(SmbException.class, () -> smbFile.renameTo(smbFile));
        }

        @Test
        void testCreateNewFileWhenExists() throws SmbException, IOException {
            // Arrange

                    throw new SmbException("Cannot rename between different trees");
                }
            }

            if (log.isDebugEnabled()) {
                log.debug("renameTo: " + getUncPath() + " -> " + dest.getUncPath());
            }

            dest.attrExpiration = dest.sizeExpiration = 0;
            /*
             * Rename Request / Response
             */

	if err := renameAll(pathJoin(export, minioMetaMultipartBucket),
		tmpOld, export); err != nil && err != errFileNotFound {
		bootLogIf(GlobalContext, fmt.Errorf("unable to rename (%s -> %s) %w, drive may be faulty please investigate",
			pathJoin(export, minioMetaMultipartBucket),
			tmpOld,
			osErrToFileErr(err)))
	}

            false
        fi
    done
}

@test "No duplicate files on Windows" {
    cat <<EOF
Please rename files so there are no repeats. For example, README.md and
Readme.md would be the same file on Windows. In this test, you would get a
warning for "readme.md" because it makes everything lowercase. There are
repeats of these filename(s) with different casing:
EOF

	stopFn := globalSftpMetrics.log(r, f.AccessKey())
	defer stopFn(0, err)

	clnt, err := f.getMinIOClient()
	if err != nil {
		return err
	}

	switch r.Method {
	case "Setstat", "Rename", "Link", "Symlink":
		return sftp.ErrSSHFxOpUnsupported

	case "Rmdir":
		bucket, prefix := path2BucketObject(r.Filepath)
		if bucket == "" {
			return errors.New("deleting all buckets not allowed")
		}

	})
	if err != nil {
		return nil, toStorageErr(err)
	}
	err = st.Results(func(r *CheckPartsResp) error {
		resp = r
		return nil
	})
	return resp, toStorageErr(err)
}

// RenameData - rename source path to destination path atomically, metadata and data file.
func (client *storageRESTClient) RenameData(ctx context.Context, srcVolume, srcPath string, fi FileInfo,
	dstVolume, dstPath string, opts RenameOptions,

filegroup(
    name = "get_tensorflow_dll_import_lib",
    srcs = ["//tensorflow:tensorflow.dll"],
    output_group = "interface_library",
    visibility = ["//visibility:public"],
)

# Rename the import library for tensorflow.dll from tensorflow.dll.if.lib to tensorflow.lib
genrule(
    name = "tensorflow_dll_import_lib",
    srcs = [":get_tensorflow_dll_import_lib"],