execute(unitOfWork)

        when:
        inputFile.write("some new content")

        then:
        outOfDate(unitOfWork, inputFilesChanged(file: [inputFile]))
    }

    def "out-of-date when any input file type changes"() {
        given:
        execute(unitOfWork)

        when:
        inputFile.delete()
        inputFile.createDir()

        then:

    StringBuilder builder = new StringBuilder();

    URL url = ResourceUtil.getResource(getClass().getName().replace('.', '/') + ".txt");

    File inputFile = URLUtil.toFile(url);

    File outputFile = new File(inputFile.getParentFile(), ".out");

    /**
     * @throws Exception
     */
    @Test
    public void testIsToOs() throws Exception {
        final int result = copy(is, os);

                @get:InputFile @get:PathSensitive(PathSensitivity.NONE) var inputFile: File? = null
                @get:OutputFile var outputFile: File? = null
                @TaskAction fun doSomething() {
                    outputFile!!.apply {
                        parentFile.mkdirs()
                        writeText(inputFile!!.readText())
                        appendText("$suffix")
                    }

                    @InputFiles
                    ConfigurableFileCollection getInputFiles()
                }

                @InputArtifact
                abstract Provider<FileSystemLocation> getInput()

                void transform(TransformOutputs outputs) {
                    def inputFile = input.get().asFile
                    println "Transforming " + inputFile.name

    }
}

abstract class Consumer : DefaultTask() {
    @get:InputFiles
    abstract val inputFiles: ListProperty<RegularFile>

    @TaskAction
    fun consume() {
        inputFiles.get().forEach { inputFile ->
            val input = inputFile.asFile
            val message = input.readText()
            logger.quiet("Read '${message}' from ${input}")
        }
    }
}

                abstract Provider<FileSystemLocation> getInput()

                void transform(TransformOutputs outputs) {
                    File inputFile = input.get().asFile
                    println "processing \${inputFile.name}"
                    def output = outputs.file(inputFile.name + "." + parameters.extension)
                    output.text = "ok"
                }
            }
        """

        when:

                @InputFile
                Path inputFile
                @InputDirectory
                Path inputDir
                @OutputFile
                Path outputFile
                @OutputDirectory
                Path outputDir

                @TaskAction
                def go() {
                    outputFile.toFile().text = inputFile.toFile().text

                @ValidationProblem inputFile

                @TaskAction void execute() {
                    println "Executed"
                }
            }

            task invalid(type: InvalidTask)
        """

        expectThatExecutionOptimizationDisabledWarningIsDisplayed(executer, dummyValidationProblem('InvalidTask', 'inputFile'), 'id', 'section')

        when:

        def inputFile = file("included/inputs/input.txt")
        inputFile.text = "first"
        singleProjectBuild("included") {
            buildFile << """
                task someTask {
                    def inputFile = file("inputs/input.txt")
                    def outputFile = file("build/output.txt")
                    inputs.file inputFile
                    outputs.file outputFile

	tests := []struct {
		name        string
		wantConfigs int
		inputFile   string
		wantErr     bool
	}{
		{
			name:        "errors if unable to unmarshal bytes",
			inputFile:   "",
			wantConfigs: 0,
			wantErr:     true,
		},
		{
			name:        "loads valid ztunnel config_dump",
			inputFile:   "testdata/dump.json",
			wantConfigs: 27,
			wantErr:     false,
		},
	}