// we compare the file created by "go build" against a file written explicitly
	// by os.WriteFile.
	//
	// (See https://go.dev/issue/62724, https://go.dev/issue/17909.)
	control := tg.path("control")
	tg.creatingTemp(control)
	if err := os.WriteFile(control, []byte("#!/bin/sh\nexit 0"), 0777); err != nil {
		t.Fatal(err)
	}
	cfi, err := os.Stat(control)
	if err != nil {
		t.Fatal(err)

	}

	tmpdir, err := os.MkdirTemp("", "TestSymbolTooLarge")
	if err != nil {
		t.Fatal(err)
	}
	defer os.RemoveAll(tmpdir)

	src := filepath.Join(tmpdir, "p.go")
	err = os.WriteFile(src, []byte("package p; var x [1<<32]byte"), 0666)
	if err != nil {
		t.Fatalf("failed to write source file: %v\n", err)
	}
	obj := filepath.Join(tmpdir, "p.o")

		for _, goarch := range goarches {
			value := 0
			if goarch == target {
				value = 1
			}
			fmt.Fprintf(&buf, "const Is%s = %d\n", strings.Title(goarch), value)
		}
		err := os.WriteFile("zgoarch_"+target+".go", buf.Bytes(), 0666)
		if err != nil {
			log.Fatal(err)
		}
	}

		t.Fatalf("succeed to start tracing second time")
	}
	Stop()
	Stop()
}

func saveTrace(t *testing.T, buf *bytes.Buffer, name string) {
	if !*saveTraces {
		return
	}
	if err := os.WriteFile(name+".trace", buf.Bytes(), 0600); err != nil {
		t.Errorf("failed to write trace file: %s", err)
	}

namespace tensorflow {
namespace generator {

class Controller {
 public:
  explicit Controller(PathConfig path_config, Env* env = Env::Default());
  virtual ~Controller();
  const void WriteFile(const string& file_path, const SourceCode& code) const;
  const std::vector<OpSpec>& GetModelOps() const;

 private:
  void InitializeOpApi();
  void BuildModel();

  // Data model: Ops to generate

	if err := cgotest.OverlayDir(modRoot, "testdata"); err != nil {
		log.Panic(err)
	}
	if err := os.Chdir(modRoot); err != nil {
		log.Panic(err)
	}
	os.Setenv("PWD", modRoot)
	if err := os.WriteFile("go.mod", []byte("module cgolife\n"), 0666); err != nil {
		log.Panic(err)
	}

	return m.Run()
}

// TestTestRun runs a test case for cgo //export.
func TestTestRun(t *testing.T) {
	testenv.MustHaveGoRun(t)

import (
	"os"
	"path/filepath"
	"testing"
)

func TestWriteTmp(t *testing.T) {
	dir, err := os.MkdirTemp("", "")
	if err != nil {
		t.Fatal(err)
	}
	defer os.RemoveAll(dir)
	err = os.WriteFile(filepath.Join(dir, "x"), nil, 0666)
	if err != nil {
		t.Fatal(err)
	}
}

func TestReadTestdata(t *testing.T) {
	_, err := os.ReadFile("testdata/foo.txt")
	if err != nil {
		t.Fatal(err)
	}

	}
	t.Parallel()
	tmp := t.TempDir()
	goBin := testenv.GoToolPath(t)
	goFile := filepath.Join(tmp, "x.go")
	file := []byte(`package main
import _ "math/big"
func main() {}
`)
	if err := os.WriteFile(goFile, file, 0644); err != nil {
		t.Fatal(err)
	}
	cmd := exec.Command(goBin, "build", "-o", "x.exe", "x.go")
	cmd.Dir = tmp
	if out, err := cmd.CombinedOutput(); err != nil {
		t.Fatalf("compile: %v, %s", err, out)

		panic(err)
	}
	defer os.RemoveAll(dir)

	args := []string{"go", "build"}
	write := func(prefix string, i int, data string) {
		filename := filepath.Join(dir, fmt.Sprintf("%s%d.go", prefix, i))
		if err := os.WriteFile(filename, []byte(data), 0o644); err != nil {
			panic(err)
		}
		args = append(args, filename)
	}

	for i := 0; i < 100; i++ {
		write("a", i, `package p
`)
	}
	for i := 0; i < 100; i++ {

	}
	diff := diff.Diff(srcPath, old, "go help documentation | gofmt", alldocs)
	if diff == nil {
		t.Logf("%s is up to date.", srcPath)
		return
	}

	if *fixDocs {
		if err := os.WriteFile(srcPath, alldocs, 0666); err != nil {
			t.Fatal(err)
		}
		t.Logf("wrote %d bytes to %s", len(alldocs), srcPath)
	} else {
		t.Logf("\n%s", diff)
		t.Errorf("%s is stale. To update, run 'go generate cmd/go'.", srcPath)