"new File(\"${filePath}\").$checkKind()"
        }
    }

    static FileCheck fileExists(String filePath) {
        new FileCheck(filePath, "exists")
    }

    static FileCheck fileIsFile(String filePath) {
        new FileCheck(filePath, "isFile")
    }

    static FileCheck fileIsDirectory(String filePath) {
        new FileCheck(filePath, "isDirectory")
    }

	exp = filepath.Join(root, "plugins/foobar")
	assert.Equal(t, exp, got)

	got = kubelet.getPodDir("abc123")
	exp = filepath.Join(root, "pods/abc123")
	assert.Equal(t, exp, got)

	got = kubelet.getPodVolumesDir("abc123")
	exp = filepath.Join(root, "pods/abc123/volumes")
	assert.Equal(t, exp, got)

	got = kubelet.getPodVolumeDir("abc123", "plugin", "foobar")

		for _, ext := range extensions {
			if filepath.Ext(d.Name()) == ext {
				matched = true
				break
			}
		}
		if matched {
			res = append(res, filepath.Join(filePath, d.Name()))
		}
	}
	return res, nil
}

func ReadDirOrFail(t test.Failer, filePath string, extensions ...string) []string {
	t.Helper()
	res, err := ReadDir(filePath, extensions...)
	if err != nil {
		t.Fatal(err)
	}

	}
	srcDir := filepath.Join(wd, "testdata", "pgo", "devirtualize")

	// Copy the module to a scratch location so we can add a go.mod.
	dir := t.TempDir()
	if err := os.Mkdir(filepath.Join(dir, "mult.pkg"), 0755); err != nil {
		t.Fatalf("error creating dir: %v", err)
	}
	for _, file := range []string{"devirt.go", "devirt_test.go", profFileName, filepath.Join("mult.pkg", "mult.go")} {

	parent := t.TempDir()
	dotGit := filepath.Join(parent, ".git")
	if err := os.Mkdir(dotGit, 000); err != nil {
		t.Fatal(err)
	}

	overlayStart := time.Now()

	goroot := filepath.Join(parent, "goroot")

	gorootSrc := filepath.Join(goroot, "src")
	if err := overlayDir(gorootSrc, filepath.Join(realGoroot, "src")); err != nil {
		t.Fatal(err)
	}

	gorootLib := filepath.Join(goroot, "lib")

	return filepath.Join(getRootDir(rootDir), istioLogsPathSubdir, namespace, pod)
}

func OperatorPath(rootDir, namespace, pod string) string {
	return filepath.Join(getRootDir(rootDir), operatorLogsPathSubdir, namespace, pod)
}

func AnalyzePath(rootDir, namespace string) string {
	return filepath.Join(getRootDir(rootDir), analyzeSubdir, namespace)
}

func ClusterInfoPath(rootDir string) string {

func writeOutFileList(t *testing.T, infiles []string, outdir, tag string) ([]string, string) {
	outfilelist := filepath.Join(outdir, tag+"outfilelist.txt")
	var sb strings.Builder
	cv := filepath.Join(outdir, "covervars.go")
	outfs := []string{cv}
	fmt.Fprintf(&sb, "%s\n", cv)
	for _, inf := range infiles {
		base := filepath.Base(inf)
		of := filepath.Join(outdir, tag+".cov."+base)
		outfs = append(outfs, of)
		fmt.Fprintf(&sb, "%s\n", of)
	}

     * @param javadoc paths to javadoc jars or javadoc folders
     * @param source paths to source jars or source folders
     * @param scope scope
     */
    public SingleEntryModuleLibrary(FilePath library, Set<FilePath> javadoc, Set<FilePath> source, String scope) {
        super(Collections.singletonList(library), javadoc, source, new ArrayList<>(), scope);
    }

    /**
     * Creates single entry module library
     *

	if err != nil {
		log.Fatal(err)
	}
	defer os.RemoveAll(d)
	targetPath := filepath.Join(d, "hello.txt")
	if err := os.WriteFile(targetPath, []byte("Hello, Gophers!"), 0644); err != nil {
		log.Fatal(err)
	}
	linkPath := filepath.Join(d, "hello.link")
	if err := os.Symlink("hello.txt", filepath.Join(d, "hello.link")); err != nil {
		if errors.Is(err, errors.ErrUnsupported) {

		return err
	}

	srcRoot, err := filepath.Abs(srcRoot)
	if err != nil {
		return err
	}

	return filepath.WalkDir(srcRoot, func(srcPath string, entry fs.DirEntry, err error) error {
		if err != nil || srcPath == srcRoot {
			return err
		}
		if filepath.Base(srcPath) == "testdata" {
			// We're just building, so no need to copy those.
			return fs.SkipDir
		}

		suffix := strings.TrimPrefix(srcPath, srcRoot)