for i := 0; i < count; i++ {
		names = append(names, fmt.Sprintf("file%03d", i))
	}

	// Make files in the temp directory
	for _, name := range names {
		err := os.WriteFile(filepath.Join(d, name), []byte("data"), 0)
		if err != nil {
			t.Fatalf("WriteFile: %v", err)
		}
	}

	// Read files using Getdirentries
	var names2 []string
	fd, err := syscall.Open(d, syscall.O_RDONLY, 0)
	if err != nil {

	correctConfigFile := filepath.Join(tmpDir, "correct_config.yaml")
	if err := os.WriteFile(correctConfigFile,
		[]byte(schedulerConfigMinimalCorrect),
		os.FileMode(0600)); err != nil {
		t.Fatal(err)
	}

	decodeErrConfigFile := filepath.Join(tmpDir, "decode_err_no_version_config.yaml")
	if err := os.WriteFile(decodeErrConfigFile,
		[]byte(schedulerConfigDecodeErr),
		os.FileMode(0600)); err != nil {
		t.Fatal(err)

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

	var buf strings.Builder
	writeHeader(&buf)
	fmt.Fprintf(&buf, "package main\n")
	fmt.Fprintln(&buf)
	fmt.Fprintf(&buf, "const defaultPkgConfig = `%s`\n", defaultpkgconfig)
	buf.WriteString(defaultCCFunc("defaultCC", defaultcc))
	buf.WriteString(defaultCCFunc("defaultCXX", defaultcxx))
	writefile(buf.String(), file, writeSkipSame)
}

		t.Skipf("Skipping large text section test in short mode or on %s", buildcfg.GOARCH)
	}
	testenv.MustHaveGoBuild(t)

	var w bytes.Buffer
	const FN = 4
	tmpdir := t.TempDir()

	if err := os.WriteFile(tmpdir+"/go.mod", []byte("module big_test\n"), 0666); err != nil {
		t.Fatal(err)
	}

	// Generate the scenario where the total amount of text exceeds the

        then:
        1 * lockManager.lock(file, {it.mode == FileLockManager.LockMode.Exclusive }, "<cache>") >> exclusiveLock
        1 * initAction.requiresInitialization(exclusiveLock) >> true
        1 * exclusiveLock.writeFile(_) >> { Runnable r -> r.run() }
        1 * initAction.initialize(exclusiveLock)
        1 * exclusiveLock.close()

        then:
        1 * lockManager.lock(file, lockOptions, "<cache>") >> sharedLock

	src := filepath.Join(tmpdir, "x.go")
	err := os.WriteFile(src, []byte(testStrictDupGoSrc), 0666)
	if err != nil {
		t.Fatal(err)
	}
	for _, af := range asmfiles {
		src = filepath.Join(tmpdir, af.fname+".s")
		err = os.WriteFile(src, []byte(af.payload), 0666)
		if err != nil {
			t.Fatal(err)
		}
	}
	src = filepath.Join(tmpdir, "go.mod")
	err = os.WriteFile(src, []byte("module teststrictdup\n"), 0666)

		}
	}
}

func writeFile(content string) (string, string, error) {
	tempDir, err := os.MkdirTemp("", "mounter_shared_test")
	if err != nil {
		return "", "", err
	}
	filename := filepath.Join(tempDir, "mountinfo")
	err = os.WriteFile(filename, []byte(content), 0600)
	if err != nil {
		os.RemoveAll(tempDir)
		return "", "", err
	}

)

func saveCreds(csrPem []byte, privPem []byte) {
	err := os.WriteFile(*outCsr, csrPem, 0o644)
	if err != nil {
		log.Fatalf("Could not write output certificate request: %s.", err)
	}

	err = os.WriteFile(*outPriv, privPem, 0o600)
	if err != nil {
		log.Fatalf("Could not write output private key: %s.", err)
	}
}

func main() {
	flag.Parse()

func writeMessage(t testing.TB, path string, msg proto.Message) {
	t.Helper()
	yml, err := protomarshal.ToYAML(msg)
	if err != nil {
		t.Fatal(err)
	}
	writeFile(t, path, yml)
}

func writeFile(t testing.TB, path, content string) {
	t.Helper()
	if err := os.WriteFile(path, []byte(content), 0o666); err != nil {
		t.Fatal(err)
	}
}

func removeSilent(path string) {
	_ = os.RemoveAll(path)
}

import org.gradle.internal.serialize.graph.ReadContext
import org.gradle.internal.serialize.graph.WriteContext
import org.gradle.internal.serialize.graph.readFile
import org.gradle.internal.serialize.graph.writeFile
import org.gradle.internal.Describables
import org.gradle.internal.component.local.model.ComponentFileArtifactIdentifier
import org.gradle.internal.model.CalculatedValueContainerFactory