private static final Logger logger = Logger.getLogger(FileFactory.class.getName());

    private final ThreadLocal<File> fileThreadLocal = new ThreadLocal<>();

    File createFile() throws IOException {
      File file = File.createTempFile("SinkSourceFile", "txt");
      fileThreadLocal.set(file);
      return file;
    }

    File getFile() {
      return fileThreadLocal.get();

		return nil, err
	}
	return d.disk.ReadFileStream(ctx, volume, path, offset, length)
}

func (d *naughtyDisk) CreateFile(ctx context.Context, origvolume, volume, path string, size int64, reader io.Reader) error {
	if err := d.calcError(); err != nil {
		return err
	}
	return d.disk.CreateFile(ctx, origvolume, volume, path, size, reader)
}

     *
     * @param path the file path to create
     * @return the created file
     * @throws CrawlerSystemException if directory creation fails
     */
    protected File createFile(final String path) {
        final String[] paths = path.split("/");
        File targetFile = baseDir;
        for (int i = 0; i < paths.length - 1; i++) {
            File file = new File(targetFile, paths[i]);

    //       /[sibling -> left]
    Path root = createTempDirectory("ClassPathTest");
    try {
      Path left = createDirectory(root.resolve("left"));
      createFile(left.resolve("some.txt"));

      Path right = createDirectory(root.resolve("right"));
      createFile(right.resolve("another.txt"));

      createSymbolicLink(left.resolve("sibling"), right);
      createSymbolicLink(right.resolve("sibling"), left);

	return errFaultyDisk
}

func (a badDisk) ReadFileStream(ctx context.Context, volume, path string, offset, length int64) (io.ReadCloser, error) {
	return nil, errFaultyDisk
}

func (a badDisk) CreateFile(ctx context.Context, origvolume, volume, path string, size int64, reader io.Reader) error {
	return errFaultyDisk
}

func (badDisk) Hostname() string {
	return ""
}

const oneMiByte = 1 * humanize.MiByte

        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
     *

	})
}

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))
}

	reader := bytes.NewReader(buf)
	respBody, err := client.call(ctx, storageRESTMethodAppendFile, values, reader, -1)
	defer xhttp.DrainBody(respBody)
	return err
}

func (client *storageRESTClient) CreateFile(ctx context.Context, origvolume, volume, path string, size int64, reader io.Reader) error {
	values := make(url.Values)
	values.Set(storageRESTVolume, volume)
	values.Set(storageRESTFilePath, path)

        for (int i = 0; i < largeContent.length; i++) {
            largeContent[i] = (byte) (i % 256);
        }
        Files.write(publicDir.resolve("largefile.bin"), largeContent);
        Files.createFile(publicDir.resolve("empty.txt"));

        // Setup special characters directory
        Files.writeString(specialDir.resolve("file with spaces.txt"), "spaces");

        // Zero byte file for test_zeroByteFile
        Path zeroDir = publicDir.resolve("zero");
        Files.createDirectory(zeroDir);
        Files.createFile(zeroDir.resolve("empty.txt"));

        MountableFile mountablePublic = MountableFile.forHostPath(publicDir.toAbsolutePath().toString());