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.

    }

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

	"strings"

	"golang.org/x/tools/cover"
)

// htmlOutput reads the profile data from profile and generates an HTML
// coverage report, writing it to outfile. If outfile is empty,
// it writes the report to a temporary file and opens it in a web browser.
func htmlOutput(profile, outfile string) error {
	profiles, err := cover.ParseProfiles(profile)
	if err != nil {
		return err
	}

	var d templateData

    def "writes report to a file"() {
        when:
        File outFile = new File(temporaryFolder.getTestDirectory(), "report.txt");
        renderer.setOutputFile(outFile);

        then:
        renderer.textOutput instanceof StreamingStyledTextOutput

        when:
        renderer.complete();

        then:
        outFile.file
        renderer.textOutput == null
    }

                @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'