verify(mockResource).renameTo(destination);
            verify(mockResource).renameTo(destination, true);
        }

        @Test
        @DisplayName("renameTo should throw NullPointerException for null destination")
        void testRenameTo_NullDestination() throws CIFSException {
            // Given
            doThrow(new NullPointerException("dest argument is null")).when(mockResource).renameTo(null);

        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

      super(file.getPath());
      this.canRename = canRename;
      this.canDelete = canDelete;
    }

    @Override
    public boolean renameTo(File to) {
      return canRename && super.renameTo(to);
    }

    @Override
    public boolean delete() {
      return canDelete && super.delete();
    }

    private static final long serialVersionUID = 0;
  }

     * @throws NullPointerException
     *             If the <code>dest</code> argument is <code>null</code>
     */
    void renameTo(SmbResource dest) throws CIFSException;

    /**
     * Changes the name of the file this <code>SmbResource</code> represents to the name
     * designated by the <code>SmbResource</code> argument.
     * <br>

            // File.renameTo operation doesn't really work across file systems.
            // So we will attempt to do a File.renameTo for efficiency and atomicity, if this fails
            // then we will use a brute force copy and delete the temporary file.
            if (!temp.renameTo(destination)) {
                try {
                    Files.copy(

    checkNotNull(from);
    checkNotNull(to);
    checkArgument(!from.equals(to), "Source %s and destination %s must be different", from, to);

    if (!from.renameTo(to)) {
      copy(from, to);
      if (!from.delete()) {
        if (!to.delete()) {
          throw new IOException("Unable to delete " + to);
        }
        throw new IOException("Unable to delete " + from);

stores such as MinIO. MapReduce workloads typically interact with object stores in the same way they do with HDFS. These workloads rely on HDFS atomic rename functionality to complete writing data to the datastore. Object storage operations are atomic by nature and they do not require/implement rename API. The default S3A committer emulates renames through copy and delete APIs. This interaction pattern causes significant loss of performance because of the write amplification. _Netflix_, for example,...

		go removeAll(file)
	}

	// Remove the entire folder in case there are leftovers that didn't get cleaned up before restart.
	go removeAll(pathJoin(diskPath, minioMetaTmpBucket+"-old"))

	// Renames and schedules for purging all bucket metacache.
	go renameAllBucketMetacache(diskPath)
}

// Following error message is added to fix a regression in release

	g := errgroup.WithNErrs(len(disks))

	// Rename file on all underlying storage disks.
	for index := range disks {
		g.Go(func() error {
			if disks[index] == nil {
				return errDiskNotFound
			}
			return disks[index].RenamePart(ctx, srcBucket, srcEntry, dstBucket, dstEntry, optsMeta, skipParent)
		}, index)
	}

	// Wait for all renames to finish.
	errs := g.Wait()

  // calculate names?

  /**
   * Creates an {@link Executor} that renames the {@link Thread threads} that its tasks run in.
   *
   * <p>The names are retrieved from the {@code nameSupplier} on the thread that is being renamed
   * right before each task is run. The renaming is best effort, if a {@link SecurityManager}