@TaskAction
                void doTask() {
                    File outputFile = getOutputDir().get().asFile
                    outputFile.deleteDir()
                    outputFile.mkdirs()
                    for (int i = 0; i < getInputCount().get(); i++) {
                        new File(outputFile, i.toString()).mkdirs()
                    }
                }
            }

 * limitations under the License.
 */

// tag::verification-failure[]
tasks.register("process") {
    def outputFile = layout.buildDirectory.file("processed.log")
    outputs.files(outputFile) // <1>

    doLast {
        def logFile = outputFile.get().asFile
        logFile << "Step 1 Complete." // <2>
        throw new VerificationException("Process failed!") // <3>

            @CacheableTask
            class CustomTask extends DefaultTask {
                @InputFile @PathSensitive(PathSensitivity.NONE) File inputFile
                @OutputFile File outputFile
                @TaskAction void doSomething() {
                    outputFile.text = inputFile.text + "$suffix"
                }
            }
        """
    }

                output = layout.buildDirectory.file("out.txt")
            }
        """
        def outputFile = file("build/out.txt")

        when:
        configurationCacheRun "a"

        then:
        result.assertTasksExecutedAndNotSkipped(":a")
        outputFile.assertIsFile()

        when:
        configurationCacheRun "a"

        then:

        result == object
        1 * object.loadDefaults()
        0 * _._
    }

    def writesObjectToFile() {
        File outputFile = new File('output')

        when:
        generator.write(object, outputFile)

        then:
        1 * object.store(outputFile)
        0 * _._
    }

        given:
        def compiler = getCompiler()
        def testDir = tmpDirProvider.testDirectory
        def outputFile = testDir.file("output.ext")

        when:
        def args = compiler.getOutputArgs(Stub(NativeCompileSpec), outputFile)

        then:
        args == [ '-o', outputFile.absoluteFile.toString() ]
    }

plugins {
    id 'java-library'
}

version = '1.0'

def buildInfo = tasks.register("buildInfo", BuildInfo) {
    version = project.version
    outputFile = layout.buildDirectory.file('generated-resources/build-info.properties')
}

sourceSets {
    main {
        output.dir(buildInfo.map { it.outputFile.asFile.get().parentFile })
    }

                """
                plugins {}
                """
            )
        )

        assertThat(
            outputFile("no-plugins.gradle.kts"),
            doesNotExist()
        )

        assertThat(
            outputFile("empty-plugins.gradle.kts"),
            doesNotExist()
        )
    }

    private

            task cacheableTask(type: MyTask) {
                inputFile = file('input.txt')
                outputFile = file('build/output.txt')
                cacheOrigin = file('cache-origin.txt')
            }

            @CacheableTask
            class MyTask extends DefaultTask {

                @OutputFile File outputFile

                @InputFile
                @PathSensitive(PathSensitivity.NONE)

    private final RegularFileProperty outputFile;
    private final Property<NativePlatform> targetPlatform;
    private final Property<NativeToolChain> toolChain;

    public StripSymbols() {
        ObjectFactory objectFactory = getProject().getObjects();

        this.binaryFile = objectFactory.fileProperty();
        this.outputFile = objectFactory.fileProperty();