*/

    static final int FILE_OVERWRITE = 0x4;

    /*
     * Open the file and overwrite it's contents or create it if it does not exist
     * aka CREATE_ALWAYS (according to the wire when calling CreateFile)
     */

    static final int FILE_OVERWRITE_IF = 0x5;

    // create options
    static final int FILE_WRITE_THROUGH = 0x00000002;
    static final int FILE_SEQUENTIAL_ONLY = 0x00000004;

		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)

        return getList(OpenSearchUrlQueue.class, sessionId, null, 0, pollingFetchSize,
                SortBuilders.fieldSort(OpenSearchUrlQueue.WEIGHT).order(SortOrder.DESC),
                SortBuilders.fieldSort(CREATE_TIME).order(SortOrder.ASC));
    }

    /**
     * Saves the session state (currently not implemented).
     *
     * @param sessionId The session ID.
     */
    @Override

	}

	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
     *

     * Field name for creation time timestamp.
     */
    protected static final String CREATE_TIME = "createTime";

    /**
     * Document type.
     */
    protected static final String _DOC = "_doc";

    /**
     * Fields that store timestamps.
     */
    protected static final String[] timestampFields = { LAST_MODIFIED, CREATE_TIME };

    /**
     * Hash function for generating IDs.
     */

    } catch (NoSuchFileException e) {
      try {
        Files.createFile(path);
      } catch (FileAlreadyExistsException ignore) {
        // The file didn't exist when we called setLastModifiedTime, but it did when we called
        // createFile, so something else created the file in between. The end result is

	})
}

func (p *xlStorageDiskIDCheck) CreateFile(ctx context.Context, origvolume, volume, path string, size int64, reader io.Reader) (err error) {
	ctx, done, err := p.TrackDiskHealth(ctx, storageMetricCreateFile, volume, path)
	if err != nil {
		return err
	}
	defer done(size, &err)

	return p.storage.CreateFile(ctx, origvolume, volume, path, size, io.NopCloser(reader))
}