}

TEST_P(ModularFileSystemTest, TestFilesExist) {
  const std::vector<std::string> filenames = {GetURIForPath("a"),
                                              GetURIForPath("b")};
  for (const auto& filename : filenames) {
    std::unique_ptr<WritableFile> file;
    Status status = env_->NewWritableFile(filename, &file);
    if (!status.ok())
      GTEST_SKIP() << "NewWritableFile() not supported: " << status;

		},
		{
			filenames: []string{"file"},
			errExp:    false,
		},
		{
			filenames: []string{"dir"},
			recursive: true,
			errExp:    false,
		},
		{
			kustomize: "dir",
			errExp:    false,
		},
	}
	for _, testcase := range testcases {
		o := &FilenameOptions{
			Kustomize: testcase.kustomize,
			Filenames: testcase.filenames,
			Recursive: testcase.recursive,
		}

     * identical to the list returned by the parameterless <code>list()</code>
     * method minus filenames filtered by the specified filter.
     *
     * @param filter
     *            a filename filter to exclude filenames from the results
     * @return <code>String[]</code> array of matching files and directories,

                                       'contrib', 'makefile', 'downloads')
  if os.path.isdir(makefile_download_dir):
    for root, _, filenames in os.walk(makefile_download_dir):
      for f in filenames:
        if f.endswith('BUILD'):
          os.remove(os.path.join(root, f))


def get_var(environ_cp,
            var_name,
            query_item,

		return
	}

	// If we have a column (//line filename:line:col form),
	// an empty filename means to use the previous filename.
	filename := text[:i-1] // lop off ":line"
	trimmed := false
	if filename == "" && ok2 {
		filename = p.base.Filename()
		trimmed = p.base.Trimmed()
	}

	p.base = NewLineBase(pos, filename, trimmed, line, col)
}

func commentText(s string) string {
	if s[:2] == "/*" {

+
Your tests can distinguish between parallel test processes by using the value of the `org.gradle.test.worker` property, which is unique for each process. You can use this for anything you want, but it's particularly useful for filenames and other resource identifiers to prevent the kind of conflict we just mentioned.

`forkEvery` — default: 0 (no maximum)::

====

As in the above example, you can use regular expressions for this or closures that use more complex logic to determine the target filename.
For example, the following task truncates filenames:

====
include::sample[dir="snippets/files/copy/kotlin",files="build.gradle.kts[tags=truncate-names-example]"]

	// file table is already de-duped.
	for i, name := range unit.FileTable {
		name := expandFile(name)
		if len(name) == 0 {
			// Can't have empty filenames, and having a unique
			// filename is quite useful for debugging.
			name = fmt.Sprintf("<missing>_%d", i)
		}
		// Note the use of "path" here and not "filepath". The compiler

		}
	}
}

func TestFileServerFS(t *testing.T) {
	filename := "index.html"
	contents := []byte("index.html says hello")
	fsys := fstest.MapFS{
		filename: {Data: contents},
	}
	ts := newClientServerTest(t, http1Mode, FileServerFS(fsys)).ts
	defer ts.Close()

	res, err := ts.Client().Get(ts.URL + "/" + filename)
	if err != nil {
		t.Fatal(err)
	}
	b, err := io.ReadAll(res.Body)

	if err := storage.WriteAll(context.Background(), volName, fileName, data); err != nil {
		t.Fatal(err)
	}
	if err := storage.storage.bitrotVerify(context.Background(), pathJoin(path, volName, fileName), size, algo, hashBytes, 0); err != nil {
		t.Fatal(err)
	}

	// 2) Whole-file bitrot check on corrupted file
	if err := storage.AppendFile(context.Background(), volName, fileName, []byte("a")); err != nil {
		t.Fatal(err)
	}