return
  for filepath in APPLE_BAZEL_FILES:
    existing_filepath = os.path.join(_TF_WORKSPACE_ROOT, filepath + '.apple')
    renamed_filepath = os.path.join(_TF_WORKSPACE_ROOT, filepath)
    symlink_force(existing_filepath, renamed_filepath)
  for filepath in IOS_FILES:
    filename = os.path.basename(filepath)
    new_filepath = os.path.join(_TF_WORKSPACE_ROOT, filename)

  const std::string filepath = GetURIForPath("a_file");
  Status status = env_->CreateDir(filepath);
  if (!status.ok()) GTEST_SKIP() << "CreateDir() not supported: " << status;

  status = env_->FileExists(filepath);
  EXPECT_PRED2(UnimplementedOrReturnsCode, status, Code::OK);
}

TEST_P(ModularFileSystemTest, TestFileExistsNotFound) {
  const std::string filepath = GetURIForPath("a_file");

		return errFileNotFound
	}

	// Validate file path length, before reading.
	filePath := pathJoin(volumeDir, path)
	if err = checkPathLength(filePath); err != nil {
		return err
	}

	srcFilePath := pathJoin(filePath, xlStorageFormatFileV1)
	dstFilePath := pathJoin(filePath, xlStorageFormatFile)

	// Renaming xl.json to xl.meta should be fully synced to disk.
	defer func() {

		tempDirIsGOPATH = true
		srcDir := filepath.Join(t.gorootTestDir, t.goDirName())
		modName := filepath.Base(srcDir)
		gopathSrcDir := filepath.Join(tempDir, "src", modName)
		runInDir = gopathSrcDir

		if err := overlayDir(gopathSrcDir, srcDir); err != nil {
			t.Fatal(err)
		}

		modFile := fmt.Sprintf("module %s\ngo 1.14\n", modName)

func loadWorkFile(path string) (workFile *modfile.WorkFile, modRoots []string, err error) {
	workDir := filepath.Dir(path)
	wf, err := ReadWorkFile(path)
	if err != nil {
		return nil, nil, err
	}
	seen := map[string]bool{}
	for _, d := range wf.Use {
		modRoot := d.Path
		if !filepath.IsAbs(modRoot) {
			modRoot = filepath.Join(workDir, modRoot)
		}

		if seen[modRoot] {

func hasSubdir(root, dir string) (rel string, ok bool) {
	const sep = string(filepath.Separator)
	root = filepath.Clean(root)
	if !strings.HasSuffix(root, sep) {
		root += sep
	}
	dir = filepath.Clean(dir)
	after, found := strings.CutPrefix(dir, root)
	if !found {
		return "", false
	}
	return filepath.ToSlash(after), true
}

// readDir calls ctxt.ReadDir (if not nil) or else os.ReadDir.

	relOutsideFile, err := filepath.Rel(filepath.Join(linkOutDir, "."), outsideFile)
	if err != nil {
		t.Fatalf("filepath.Rel: %v", err)
	}
	relOutLinkFile := filepath.Join(linkOutDir, "file.rel.out.link")
	if err := Symlink(relOutsideFile, relOutLinkFile); err != nil {
		t.Fatalf("Symlink: %v", err)
	}

	// Last, we create the relative symlink pointing inside.

	for _, pkg := range pkgs {
		dirs = append(dirs, filepath.Join("src", pkg))
	}
	dirs = append(dirs,
		filepath.Join("pkg/tool", goHostOS+"_"+goHostArch),
		"pkg/include",
	)
	for _, copydir := range dirs {
		srcdir := filepath.Join(testGOROOT, copydir)
		tg.tempDir(filepath.Join("goroot", copydir))
		err := filepath.WalkDir(srcdir,
			func(path string, info fs.DirEntry, err error) error {

				if err != nil {
					t.Fatalf("failed to attach: %v", err)
				}
			}

			parent := filepath.Dir(tc.deviceMountPath)
			filePath := filepath.Join(parent, "newfile")
			if tc.populateDeviceMountPath {
				// We need to create the deviceMountPath before we Mount,
				// so that we can correctly create the file without errors.

	// suffice here, but that requires deviating from the infrastructure
	// provided by `run`.
	gitDir := chomp(run(goroot, 0, "git", "rev-parse", "--git-dir"))
	if !filepath.IsAbs(gitDir) {
		gitDir = filepath.Join(goroot, gitDir)
	}
	return isdir(gitDir)
}

/*
 * Initial tree setup.
 */

// The old tools that no longer live in $GOBIN or $GOROOT/bin.
var oldtool = []string{