}
                }
            }

            abstract class Producer extends DefaultTask {
                @OutputFile abstract RegularFileProperty getOutputFile()
                @TaskAction def produce() {
                    outputFile.get().asFile << "42"
                }
            }

            class PrintAction implements FlowAction<Parameters> {

    String taskWithMultipleOptionsForSingleProperty(String optionType, String optionName, String optionDescription) {
        """
            import org.gradle.api.DefaultTask;
            import org.gradle.api.tasks.TaskAction;
            import org.gradle.api.tasks.options.Option;

            import java.util.List;

            public class SampleTask extends DefaultTask {
                private $optionType myProp;

        given:
        buildFile << """
            abstract class MyTask extends DefaultTask {

                @Input abstract Property<String> getMessage()

                @TaskAction def action() {
                    println(message.get())
                }
            }
            tasks.register("myTask", MyTask) {
                // use an undeclared input so we can test --refresh-dependencies

        given:
        buildFile """
            abstract class PrintInputs extends DefaultTask {

                @InputFiles
                abstract ConfigurableFileCollection getInputFiles()

                @TaskAction
                def printInputs() {
                    getInputFiles().files.each {
                        println('*' + it.name + '*')
                    }
                }
            }

                    private static final AtomicInteger value = new AtomicInteger();

                    private final String projectName = getProject().getName();

                    @TaskAction
                    void printValue() {
                        // When ClassLoaders are reused
                        // the 1st run should print `<project name>.value = 1`

/**
 * Sorts the stored rules, so we keep a deterministic order when we add new rules.
 */
abstract class ReorderArchUnitRulesTask : DefaultTask() {
    @get:OutputFile
    abstract var ruleFile: File

    @TaskAction
    fun resortStoredRules() {
        val lines = ruleFile.readLines()
        val sortedLines = lines.sortedBy { line ->
            // We sort by the rule name
            line.substringBefore("=")
        }

                @Input
                abstract Property<String> getMyProperty();

                @OutputFile
                abstract RegularFileProperty getOutputFile()

                @TaskAction
                void doWork() {
                    getOutputFile().asFile.get().write(getMyProperty().get())
                }
            }

            def touchFsInEvaluation = provider {

                TaskWithComplexInputs() {
                    def result = name == "never"
                    outputs.upToDateWhen { !result }
                }

                @TaskAction
                def go() {
                    outputFile.get().asFile.text = "some-derived-value"
                }
            }

            task never(type: TaskWithComplexInputs) {

            class MyIncrementalTask extends DefaultTask {
                ${supportsInputChanges ? "@Incremental" : ""}
                @InputDirectory
                def File inputDir
                @TaskAction
                void doSomething(${parameterType} inputs) {}

                @Optional
                @OutputFile
                public File getOutputFile() {
                    return null;

            abstract class ProblemReportingTask extends DefaultTask {
                @Inject
                protected abstract Problems getProblems();

                @TaskAction
                void run() {
                    $taskActionMethodBody
                }
            }

            tasks.register("reportProblem", ProblemReportingTask)
        """
    }