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++ {

import java.io.Closeable;
import java.io.File;

public interface FileLock extends Closeable, FileAccess {
    /**
     * Returns true if the most recent mutation method ({@link #updateFile(Runnable)} or {@link #writeFile(Runnable)} attempted by any process succeeded
     * (ie a process did not crash while updating the target file).
     *
     * Returns false if no mutation method has ever been called for the target file.
     */

	}
	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)

// present in the coverage report from F.
func genAuxMeta(t *testing.T, dstdir string) (string, string) {
	// Do a GOCOVERDIR=<tmp> go run hello.go
	src := filepath.Join(dstdir, "hello.go")
	if err := os.WriteFile(src, []byte(hellogo), 0777); err != nil {
		t.Fatalf("write failed: %v", err)
	}
	args := []string{"run", "-covermode=" + testing.CoverMode(), src}
	cmd := exec.Command(testenv.GoToolPath(t), args...)

 * <li><code>TransactNamedPipe</code> A message-type pipe call that
 * writes to and reads from an existing pipe descriptor in one operation.
 * <li><code>CreateFile</code>, <code>ReadFile</code>,
 * <code>WriteFile</code>, and <code>CloseFile</code> A byte-type pipe can
 * be opened, written to, read from and closed using the standard Win32
 * file operations.
 * </ul>
 *
 * <p>

    @Suppress("unused")
    @TaskAction
    fun run() {
        outputDir.get().asFile.apply {
            recreate()
            writeFiles()
        }
    }

    protected
    fun File.writeFile(relativePath: String, text: String) {
        resolve(relativePath).apply {
            parentFile.mkdirs()
            writeText(text)
        }
    }

    private
    fun File.recreate() {

  c <- 1
}
`

func main() {
	dir, err := ioutil.TempDir("", "21576")
	if err != nil {
		log.Fatal(err)
	}
	defer os.RemoveAll(dir)

	file := filepath.Join(dir, "main.go")
	if err := ioutil.WriteFile(file, []byte(prog), 0655); err != nil {
		log.Fatalf("Write error %v", err)
	}

	// Using a timeout of 1 minute in case other factors might slow
	// down the start of "go run". See https://golang.org/issue/34836.

            return "Unable to read file '" + file + "' due to: " + e.toString();
        }
    }

    public static void writeFile(String content, File destination) {
        writeFile(content, destination, Charset.defaultCharset().name());
    }

    public static void writeFile(String content, File destination, String encoding) {
        try {
            FileUtils.writeStringToFile(destination, content, encoding);

    }

    static void unlockUncleanly(File target) {
        def lock = createDefaultFileLock(target)
        try {
            lock.writeFile {
                throw new AnException()
            }
        } catch (AnException e) {
            lock.close()
        }
        lock = createDefaultFileLock(target)
        try {

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