std::unique_ptr<raw_ostream> os;
  std::string filepath;
  Status result = CreateFileForDumping(name, &os, &filepath, dirname);
  if (!result.ok()) return std::string(result.message());

  (*os) << content;
  LOG(INFO) << "Outputted requested string to '" << filepath << "'";
  return filepath;
}

void SetCrashReproducer(mlir::PassManager& pm, llvm::StringRef dir_path) {

				"--data-dir=/var/lib/etcd",
				"--cert-file=" + filepath.FromSlash(kubeadmconstants.EtcdServerCertName),
				"--key-file=" + filepath.FromSlash(kubeadmconstants.EtcdServerKeyName),
				"--trusted-ca-file=" + filepath.FromSlash(kubeadmconstants.EtcdCACertName),
				"--client-cert-auth=true",
				"--peer-cert-file=" + filepath.FromSlash(kubeadmconstants.EtcdPeerCertName),
				"--peer-key-file=" + filepath.FromSlash(kubeadmconstants.EtcdPeerKeyName),

func getDefaultConfigDir() string {
	homeDir, err := homedir.Dir()
	if err != nil {
		return ""
	}

	return filepath.Join(homeDir, defaultMinioConfigDir)
}

func getDefaultCertsDir() string {
	return filepath.Join(getDefaultConfigDir(), certsDir)
}

func getDefaultCertsCADir() string {
	return filepath.Join(getDefaultCertsDir(), certsCADir)
}

var (
	// Default config, certs and CA directories.

	// Run the assembler and compiler manually.
	tmpdir := t.TempDir()
	asmSrc := filepath.Join("testdata", "x.s")
	goSrc := filepath.Join("testdata", "x.go")
	symabi := filepath.Join(tmpdir, "symabi")
	obj := filepath.Join(tmpdir, "x.o")

	// Write an importcfg file for the dependencies of the package.
	importcfgfile := filepath.Join(tmpdir, "hello.importcfg")
	testenv.WriteImportcfg(t, importcfgfile, nil, "internal/abi")

			assertDirEmpty(t, filepath.Join(tmpDir, "manifests"))
			assertDirEmpty(t, filepath.Join(tmpDir, "pki"))
			assertDirEmpty(t, filepath.Join(tmpDir, "tmp"))

			// Verify the files as requested by the test:
			for _, path := range test.verifyExists {
				assertExists(t, filepath.Join(tmpDir, path))
			}
			for _, path := range test.verifyNotExists {

public class GrammarFileMetadata {
    private final File filePath;
    private final antlr.preprocessor.GrammarFile antlrGrammarFile;
    private final String packageName;
    private List<GrammarMetadata> grammarMetadatas = new ArrayList<GrammarMetadata>();

    public GrammarFileMetadata(File filePath, antlr.preprocessor.GrammarFile antlrGrammarFile, String packageName) {
        this.filePath = filePath;
        this.antlrGrammarFile = antlrGrammarFile;

	assert.NoError(t, err)
	assert.Equal(t, 0, len(events))

	// Call probe after a file is added. Should return 1 event.

	// add driver
	const driverName2 = "fake-driver2"
	driverPath := filepath.Join(pluginDir, driverName2)
	executablePath := filepath.Join(driverPath, driverName2)
	installDriver(driverName2, fs)
	watcher.TriggerEvent(fsnotify.Create, driverPath)
	watcher.TriggerEvent(fsnotify.Create, executablePath)

	// Act

	dir := t.TempDir()
	hello := filepath.Join(dir, "hello.go")
	prog := `
		package main
		func main() {
			println("hello world")
		}
	`
	err := os.WriteFile(hello, []byte(prog), 0666)
	if err != nil {
		t.Fatal(err)
	}

	run := func(args ...string) string {
		return doRun(t, dir, args...)
	}

	importcfgfile := filepath.Join(dir, "hello.importcfg")

	tmpdir := t.TempDir()

	aSrc := filepath.Join("testdata", "testIndexMismatch", "a.go")
	bSrc := filepath.Join("testdata", "testIndexMismatch", "b.go")
	mSrc := filepath.Join("testdata", "testIndexMismatch", "main.go")
	aObj := filepath.Join(tmpdir, "a.o")
	mObj := filepath.Join(tmpdir, "main.o")
	exe := filepath.Join(tmpdir, "main.exe")

	importcfgFile := filepath.Join(tmpdir, "runtime.importcfg")

	workDir := filepath.Dir(gowork) // absolute, since gowork itself is absolute

	haveDirs := make(map[string][]string) // absolute → original(s)
	for _, use := range wf.Use {
		var abs string
		if filepath.IsAbs(use.Path) {
			abs = filepath.Clean(use.Path)
		} else {
			abs = filepath.Join(workDir, use.Path)
		}
		haveDirs[abs] = append(haveDirs[abs], use.Path)
	}