buildFile << """
            task foo {
                def outFile = project.file("out.txt")
                outputs.file(outFile)
                doLast {
                    if (outFile.exists()) {
                        throw new RuntimeException("Boo!")
                    }
                    outFile << "xxx"
                }
            }
        """

        expect:

            import ${OutputFile.name}

            class ProducerTask extends DefaultTask {
                @OutputFile
                final RegularFileProperty outFile = project.objects.fileProperty()

                @TaskAction
                def run() {
                    outFile.get().asFile.text = "content"
                }
            }
        """
    }

    @Override
    boolean nestedGetterIsFinal() {
        true

            class SomePlugin implements Plugin<Project> {
                void apply(Project project) {
                    project.tasks.register("producer", ProducerTask) {
                        outFile = project.layout.buildDirectory.file("intermediate.txt")
                    }
                }
            }
        """
        taskDefinition()
    }

    @Override

            import ${OutputFile.name}

            open class ProducerTask: DefaultTask() {
                @OutputFile
                val outFile: RegularFileProperty = project.objects.fileProperty()

                @TaskAction
                fun run() {
                    outFile.get().asFile.writeText("content")
                }
            }
        """
    }

    @Override

go 1.22

use ./mod
-- mod/go.mod --
module example.com/mod
-- mod/gen.go --
//go:generate go run gen.go got.txt

package main

import "os"

func main() {
    outfile := os.Args[1]
    os.WriteFile(outfile, []byte("Hello World!\n"), 0644)
}
-- want.txt --

	srcfile := filepath.Join(tempdir, "go-bug.c")
	outfile := filepath.Join(tempdir, "go-bug")
	err := os.WriteFile(srcfile, src, 0644)
	if err != nil {
		return
	}
	defer os.Remove(srcfile)
	cmd := exec.Command("gcc", "-o", outfile, srcfile)
	if _, err = cmd.CombinedOutput(); err != nil {
		return
	}
	defer os.Remove(outfile)

	cmd = exec.Command("ldd", outfile)
	out, err := cmd.CombinedOutput()
	if err != nil {

	// concurrentSATokenSyncs is the number of service account token syncing operations
	// that will be done concurrently.
	ConcurrentSATokenSyncs int32
	// rootCAFile is the root certificate authority will be included in service
	// account's token secret. This must be a valid PEM-encoded CA bundle.
	RootCAFile string
}

type LegacySATokenCleanerConfiguration struct {
	// CleanUpPeriod is the period of time since the last usage of an

	echo "// and holds raw certificates for the webhook tests."
	echo ""
	echo "package testcerts"
} >> $outfile

for file in CACert ServerKey ServerCert ClientKey ClientCert; do
	data=$(cat ${file}.pem)
	{
		echo ""
		echo "// ${file} is a test cert for dynamic admission controller."
		echo "var $file = []byte(\`$data\`)"
	} >> $outfile
done

# Clean up after we're done.
rm ./*.pem
rm ./*.csr
rm ./*.srl

openssl x509 -req -in client.csr -CA CACert.pem -CAkey CAKey.pem -CAcreateserial -out ClientCert.pem -days 100000 -extensions v3_req -extfile client.conf

outfile=certs.go

cat > $outfile << EOF
/*
Copyright 2017 The Kubernetes Authors.

Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.

		t.Fatal(err)
	}
	outFile := filepath.Join(td, "issue51939.exe")
	goTool := testenv.GoToolPath(t)
	cmd := testenv.Command(t, goTool, "build", "-o", outFile, goFile)
	if out, err := cmd.CombinedOutput(); err != nil {
		t.Logf("%s", out)
		t.Fatal(err)
	}

	ef, err := elf.Open(outFile)
	if err != nil {
		t.Fatal(err)
	}

	for _, s := range ef.Sections {