fileSize, err := strconv.Atoi(fileSizeStr)
	if err != nil {
		s.writeErrorResponse(w, err)
		return
	}

	done, body := keepHTTPReqResponseAlive(w, r)
	done(s.getStorage().CreateFile(r.Context(), origvolume, volume, filePath, int64(fileSize), body))
}

// DeleteVersionHandler delete updated metadata.

			// prematurely closed and we do not find any xl.meta or
			// part.1's - in such a scenario we must return as if client
			// disconnected. This means that erasure.Encode() CreateFile()
			// did not do anything.
			return pi, IncompleteBody{Bucket: bucket, Object: object}
		}

		return pi, toObjectErr(err, minioMetaMultipartBucket, partPath)
	}

	// Return success.

		if length != -1 {
			bitrotSumsTotalSize := ceilFrac(length, shardSize) * int64(h.Size()) // Size used for storing bitrot checksums.
			totalFileSize = bitrotSumsTotalSize + length
		}
		rb.CloseWithError(disk.CreateFile(context.TODO(), origvolume, volume, filePath, totalFileSize, rb))
	}()
	return bw
}

// ReadAt() implementation which verifies the bitrot hash available as part of the stream.
type streamingBitrotReader struct {

	}

	globalLocalDrivesMu.RLock()
	localDrives := cloneDrives(globalLocalDrivesMap)
	globalLocalDrivesMu.RUnlock()

	for _, localDrive := range localDrives {
		r := newReader()
		err := localDrive.CreateFile(context.Background(), "", minioMetaBucket, pathJoin(healMRFDir, "list.bin"), -1, r)
		r.Close()
		if err == nil {
			break
		}
	}
}

func (m *mrfState) startMRFPersistence() {

        // Test simulating concurrent access scenario
        Path tempDir = Files.createTempDirectory("concurrent_test");
        try {
            Path targetFile = tempDir.resolve("target.tmp");
            Files.createFile(targetFile);

            // First delete succeeds
            assertTrue(Files.deleteIfExists(targetFile));

            // Second delete returns false (file already gone)

	}

	shareflag := uint32(syscall.FILE_SHARE_READ | syscall.FILE_SHARE_WRITE | syscall.FILE_SHARE_DELETE)
	accessAttr := uint32(syscall.FILE_ATTRIBUTE_NORMAL | 0x80000000)

	fd, err := syscall.CreateFile(pathp, access, shareflag, nil, createflag, accessAttr, 0)
	if err != nil {
		return nil, err
	}

	return os.NewFile(uintptr(fd), path), nil
}

func lockFile(fd syscall.Handle, flags uint32) error {

        final Path baseDir = tempFolder.getRoot().toPath();
        final Path subDir = Files.createDirectory(baseDir.resolve("subdir"));
        final Path file = Files.createFile(subDir.resolve("test.txt"));

        assertTrue("Path inside base should be allowed", FileUtil.isPathSafe(file, baseDir));
    }

    /**
     * Test isPathSafe with path outside base directory
     *

			// prematurely closed and we do not find any xl.meta or
			// part.1's - in such a scenario we must return as if client
			// disconnected. This means that erasure.Encode() CreateFile()
			// did not do anything.
			return ObjectInfo{}, IncompleteBody{Bucket: bucket, Object: object}
		}
		return ObjectInfo{}, toObjectErr(err, bucket, object)
	}

	}

	globalLocalDrivesMu.RLock()
	localDrives := cloneDrives(globalLocalDrivesMap)
	globalLocalDrivesMu.RUnlock()

	for _, localDrive := range localDrives {
		r := newReader()
		err := localDrive.CreateFile(ctx, "", minioMetaBucket, pathJoin(replicationMRFDir, globalLocalNodeNameHex+".bin"), -1, r)
		r.Close()
		if err == nil {
			break
		}
	}
}

// save mrf entries to nodenamehex.bin

    static Stream<Arguments> longGetterProvider() {
        return Stream.of(Arguments.of((LongGetter) FileEntry::createTime, -1L, "negative createTime"),
                Arguments.of((LongGetter) FileEntry::createTime, 0L, "zero createTime"),
                Arguments.of((LongGetter) FileEntry::createTime, Long.MAX_VALUE, "max createTime"),

                Arguments.of((LongGetter) FileEntry::lastModified, -2L, "negative lastModified"),