t.Fatal(err)
	}
	defer RemoveAll(tempDir)
	filename := filepath.Join(tempDir, "blurp.txt")

	shmorp := []byte("shmorp")
	florp := []byte("florp")
	err = WriteFile(filename, shmorp, 0444)
	if err != nil {
		t.Fatalf("WriteFile %s: %v", filename, err)
	}
	err = WriteFile(filename, florp, 0444)
	if err == nil {
		t.Fatalf("Expected an error when writing to read-only file %s", filename)
	}
	got, err := ReadFile(filename)

        writeFile(settingsFile, "rootProject.name = 'hello-world'");
        String buildFileContent = "task helloWorld {" +
                                  "    doLast {" +
                                  "        println 'Hello world!'" +
                                  "    }" +
                                  "}";
        writeFile(buildFile, buildFileContent);

TEXT runtime·callbackasm(SB),NOSPLIT|NOFRAME,$0
`)
	for i := 0; i < maxCallback; i++ {
		buf.WriteString("\tCALL\truntime·callbackasm1(SB)\n")
	}

	filename := fmt.Sprintf("zcallback_windows.s")
	err := os.WriteFile(filename, buf.Bytes(), 0666)
	if err != nil {
		fmt.Fprintf(os.Stderr, "wincallback: %s\n", err)
		os.Exit(2)
	}
}

func genasmArm() {
	var buf bytes.Buffer

	g := NewGomegaWithT(t)

	watchDir := t.TempDir()

	watchFile1 := path.Join(watchDir, "test1.conf")
	err := os.WriteFile(watchFile1, []byte("foo: bar\n"), 0o640)
	g.Expect(err).NotTo(HaveOccurred())

	watchFile2 := path.Join(watchDir, "test2.conf")
	err = os.WriteFile(watchFile2, []byte("foo: baz\n"), 0o640)
	g.Expect(err).NotTo(HaveOccurred())

	return watchFile1, watchFile2
}

	fmt.Fprintf(&buf, "const defaultGOARCH = runtime.GOARCH\n")

	writefile(buf.String(), file, writeSkipSame)
}

// mkobjabi writes cmd/internal/objabi/zbootstrap.go:
//
//	package objabi
//
// (Nothing right now!)
func mkobjabi(file string) {
	var buf strings.Builder
	writeHeader(&buf)
	fmt.Fprintf(&buf, "package objabi\n")

	writefile(buf.String(), file, writeSkipSame)

    @TaskAction
    public void perform() throws IOException {
        for (int i = 1; i <= getFileCount().get(); i++) {
            writeFile(new File(getGeneratedFileDir().get().getAsFile(), i + ".txt"), getContent().get());
        }
    }

    private void writeFile(File destination, String content) throws IOException {
        BufferedWriter output = null;
        try {

    }

    def "acquires exclusive lock to write file"() {
        def action = {} as Runnable

        when:
        lock.writeFile(action)

        then:
        !file.exists()
        1 * manager.lock(file, mode(LockMode.Exclusive), "some-lock") >> targetLock
        1 * targetLock.writeFile(action)
        1 * targetLock.close()
        0 * targetLock._
    }

    def "can read from file"() {
        given:

            String parent = name.substring(0, separator);
            String child = name.substring(separator + 1);
            encoder.writeByte((byte) name.charAt(separator));
            writeName(parent, encoder);
            writeName(child, encoder);
        } else {
            encoder.writeByte((byte) 0);
            encoder.writeString(name);
        }
    }

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

	writeFile := os.NewFile(uintptr(fds[0]), "write-socket")
	defer writeFile.Close()
	readFile := os.NewFile(uintptr(fds[1]), "read-socket")
	defer readFile.Close()

	cw, err := FileConn(writeFile)
	if err != nil {
		t.Fatalf("FileConn: %v", err)
	}
	defer cw.Close()
	cr, err := FileConn(readFile)
	if err != nil {

	if err := os.Mkdir(lineDupDir, 0777); err != nil {
		t.Fatal(err)
	}

	if err := os.WriteFile(filepath.Join(lineDupDir, "go.mod"), []byte("module linedup\n"), 0666); err != nil {
		t.Fatal(err)
	}
	if err := os.WriteFile(lineDupGo, []byte(lineDupContents), 0444); err != nil {
		t.Fatal(err)
	}
	if err := os.WriteFile(lineDupTestGo, []byte(lineDupTestContents), 0444); err != nil {
		t.Fatal(err)
	}