logger.quiet("Wrote '${message}' to ${output}")
    }
}

abstract class Consumer extends DefaultTask {
    @InputFiles
    abstract ListProperty<RegularFile> getInputFiles()

    @TaskAction
    void consume() {
        inputFiles.get().each { inputFile ->
            def input = inputFile.asFile
            def message = input.text
            logger.quiet("Read '${message}' from ${input}")
        }
    }
}

        TaskWithNestedIterable                    | [new Bean()]                   | ["beans.\$0"]                                   | ["beans.\$0.inputFile"] | []
        TaskWithNestedBeanWithPrivateClass        | [null, null]                   | ["bean"]                                        | ["bean.inputFile"]      | []

        pluginBuilder.addPlugin("""
            def inputFile = project.file("input.txt")
            def snapshottingService = project.services.get(${SnapshottingService.name})
            def snapshot = snapshottingService.snapshotFor(inputFile.toPath())

            println("Snapshot for input file \${inputFile.name} is \$snapshot")
        """
        )
        pluginBuilder.generateForBuildSrc()

            class SimpleTask extends DefaultTask {
                @InputFile
                File inputFile = project.file("input.txt")

                @OutputFile
                File outputFile = new File(project.buildDir, "output.txt")

                @TaskAction
                void generate() {
                    outputFile.text = inputFile.text
                }
            }

        def inputFileName = "input.txt"
        def inputFile = file(inputFileName)
        inputFile << 'content'

        def outputDirectory = new File(drive)

        def taskName = 'outputFromFilesystemRoot'
        def script = """
            class InputFileToOutputDirectoryCopyAction extends DefaultTask {
                @InputFile File input
                @OutputDirectory File outputDirectory

    private TestFile inputFile = file('input.txt')
    private TestFile cacheOriginInputFile = file('cache-origin.txt')
    private TestFile outputFile = file('build/output.txt')
    private String cacheableTask = ':cacheableTask'
    private BuildCacheOperationFixtures cacheOperations = new BuildCacheOperationFixtures(executer, temporaryFolder)

    def setup() {
        inputFile.text = 'This is the input'

            class CustomTask extends DefaultTask {
                @InputFile
                @PathSensitive(PathSensitivity.NONE)
                File inputFile

                @OutputFile File outputFile

                @TaskAction void doSomething() {
                    outputFile.parentFile.mkdirs()
                    outputFile.text = inputFile.text + '$suffix'
                }
            }

                    outputFile.text = "produced"
                }
            }

            task consumer {
                def inputFile = file("output.txt")
                inputs.files(inputFile)
                doLast {
                    println "Hello " + inputFile.text
                }
            }
        """

        when:
        runAndFail("producer", "consumer")
        then:

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

 */
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 =