task someTask {
                def inputFile = file("inputs/input.txt")
                def outputFile = file("build/output.txt")
                inputs.file inputFile
                outputs.file outputFile
                doLast {
                    outputFile.parentFile.mkdirs()
                    outputFile.text = inputFile.text
                }
            }
        """

                extension = "";
            }
        } else {
            filePrefix = "none";
            extension = "";
        }
        File inputFile = null;
        File outputFile = null;
        try {
            inputFile = File.createTempFile("jodextin_" + filePrefix + "_", StringUtil.isNotBlank(extension) ? "." + extension : extension,
                    tempDir);

import org.gradle.api.tasks.Classpath;
import org.gradle.api.tasks.Console;
import org.gradle.api.tasks.IgnoreEmptyDirectories;
import org.gradle.api.tasks.Input;
import org.gradle.api.tasks.InputFiles;
import org.gradle.api.tasks.Internal;
import org.gradle.api.tasks.Optional;
import org.gradle.api.tasks.PathSensitive;
import org.gradle.api.tasks.PathSensitivity;
import org.gradle.process.ExecSpec;

                }
            }

            ${verifyDaemonsTask}
        """

        when:
        inputFile.text = initialSourceContent

        then:
        succeeds(compileTaskName)

        when:
        inputFile.text = changedSourceContent

        then:
        buildTriggeredAndSucceeded()

        and:

 */
fun main(vararg args: String) {
  System.setProperty("junit.jupiter.extensions.autodetection.enabled", "true")

  val inputFile = if (args.isNotEmpty()) File(args[0]) else null
  val selectors = testSelectors(inputFile)

  val summaryListener = SummaryGeneratingListener()
  val treeListener = treeListener()

  val jupiterTestEngine = buildTestEngine()

  val config =

 * limitations under the License.
 */

package org.gradle.api.internal.tasks.properties;

import org.gradle.api.tasks.Classpath;
import org.gradle.api.tasks.CompileClasspath;
import org.gradle.api.tasks.InputFiles;
import org.gradle.internal.execution.model.annotations.ModifierAnnotationCategory;
import org.gradle.internal.properties.annotations.PropertyTypeResolver;
import org.gradle.internal.reflect.annotations.AnnotationCategory;

        }

        TaskFixture localState(String path) {
            produces(path, ProductionType.LOCAL_STATE)
            return this
        }

        TaskFixture inputFiles(String path) {
            inputFiles.add(path)
            return this
        }

        String getName() {
            return path.split(':').last()
        }

        String getFullPath() {

import org.gradle.api.file.RegularFile;
import org.gradle.api.file.RegularFileProperty;
import org.gradle.api.provider.ListProperty;
import org.gradle.api.tasks.Input;
import org.gradle.api.tasks.InputFiles;
import org.gradle.api.tasks.OutputFile;
import org.gradle.api.tasks.TaskAction;

import java.io.File;
import java.io.FileWriter;
import java.io.IOException;
import java.io.PrintWriter;

     */
    @PathSensitive(PathSensitivity.NONE)
    @InputFiles
    public ConfigurableFileCollection getExecutionData() {
        return executionData;
    }

    /**
     * Source sets that coverage should be reported for.
     */
    @IgnoreEmptyDirectories
    @PathSensitive(PathSensitivity.RELATIVE)
    @InputFiles
    public ConfigurableFileCollection getSourceDirectories() {

    def "should trigger rebuild when java source file is changed during build execution"() {
        given:
        def inputFile = file("src/main/java/Thing.java")
        inputFile << "class Thing {}"
        inputFile.makeOlder()

        when:
        buildFile << """
apply plugin: 'java'

task postCompile {
    doLast {
        if (!file('change-triggered').exists()) {