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 {

		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 {

    }

    def "task is cacheable after previous failure"() {
        buildFile << """
            task foo {
                def outFile = project.file("out.txt")
                outputs.file(outFile)
                outputs.cacheIf { true }
                doLast {
                    outFile << "xxx"
                    if (System.getProperty("fail")) {
                        throw new RuntimeException("Boo!")
                    }

    def "task @InputFiles file collection closure is called once only when task executes"() {
        taskTypeWithInputFileCollection()
        buildFile """
            task merge(type: InputFilesTask) {
                outFile = file("out.txt")
                inFiles.from {
                    println("calculating value")
                    return 'in.txt'
                }
            }
"""
        file("in.txt").text = "in"

                @OutputFile
                abstract RegularFileProperty getOutFile()

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

    @Override
    void taskWithNestedBeanDefinition() {
        pluginDir.file("src/main/groovy/ProducerTask.groovy") << """

        }

        task resolve {
            inputs.files(configurations.conf)
            def outFile = file("out.txt")
            outputs.file(outFile)
            doLast {
               outFile << 'Hello'
            }
        }

        checkDeps.dependsOn resolve

        """

        when:
        args '-Pproject.version=1.1'