tasks.register("myTask") {
              ${variableDefinition} inputFile = file("input/marker")
              inputs.files(inputFile)
              outputs.files("build/marker")
              doLast {
                println("value: " + inputFile.${readTextMethod})
              }
            }
        """

        when:
        succeeds(":myTask")
        then:

        }
        executer.requireDaemon()
    }

    def "emits build operations when watching is enabled"() {
        when:
        withWatchFs().run "myTask"
        then:
        executedAndNotSkipped(":myTask")
        def startedResult = buildStartedResult()
        startedResult.watchingEnabled
        startedResult.startedWatching
        startedResult.statistics == null

              }
            }

            tasks.register("myTask", MyTask.class)
        '''

        when:
        succeeds('myTask', '--serial=1234', '--serialNumber=4321')

        then:
        result.assertTaskExecuted(':myTask').assertOutputContains('Serial: 4321')

        when:
        succeeds('myTask', '--serialNumber=4321', '--serial=1234')

        then:

package org.example

        builder.sourceFile("com/example/MyTask.java") << """
            package com.example;

            import org.gradle.api.*;
            import org.gradle.api.tasks.*;

            public class MyTask extends DefaultTask {
                public MyTask() {
                    getInputs().file("somefile");
                    getInputs().files("afile", "anotherfile");

        buildFile << """
            task myTask {
              def inputFile = file("input/marker")
              inputs.files inputFile
              outputs.files "build/marker"
              doLast {
                println "exists: " + inputFile.exists()
              }
            }
        """

        when:
        succeeds("myTask")
        then:
        output.contains "exists: false"

            }

            abstract class MyTask extends DefaultTask {
                @Input
                abstract Property<String> getScriptOutput()
                @TaskAction
                def action() {
                    println(scriptOutput.get())
                }
            }
            tasks.register("printScriptOutput", MyTask) {
                scriptOutput = execProvider.standardOutput.asText

    }

    TestFile getJavaTaskSource() {
        source("src/main/java/MyTask.java")
    }

    TestFile getGroovyTaskSource() {
        buildFile  """
            apply plugin: "groovy"
        """
        source("src/main/groovy/MyTask.groovy")
    }

    TestFile getKotlinTaskSource() {
        buildFile.delete()
        buildKotlinFile << """

            }
        """

        when:
        runner()
            .withArguments('--configuration-cache', 'myTask')    // <1>
            .build()

        and:
        def result = runner()
            .withArguments('--configuration-cache', 'myTask')    // <2>
            .build()

        then:
        result.output.contains('Reusing configuration cache.')      // <3>

        // given: buildSrc memory hog
        val memoryHogMb = 128
        val myTask = withFile(
            "buildSrc/src/main/groovy/MyTask.groovy",
            """
            import org.gradle.api.*
            import org.gradle.api.tasks.*

            class MyTask extends DefaultTask {
                static final byte[][] MEMORY_HOG = new byte[1024][1024 * $memoryHogMb]