)
    }

    def "reads and writes output only transformation results"() {
        expect:
        assertCanWriteAndReadResult(
            outputDir.file("first"),
            outputDir.file("second"),
            outputDir
        )
    }

    def "reads and writes input only transformation results"() {
        expect:
        assertCanWriteAndReadResult(
            inputArtifact.file("inside"),

    }

    def "previous outputs remain outputs"() {
        def outputDir = temporaryFolder.file("outputDir").createDir()
        def outputDirFile = outputDir.file("outputOfCurrent").createFile()
        def previousExecution = snapshotOutput(outputDir)
        outputDir.file("outputOfOther").createFile()
        def beforeExecution = snapshotOutput(outputDir)

        when:

        when:
        cleanupOutput(outputDir, subDir, *outputFiles)
        then:
        _ * dirSafeToDelete.test(subDir) >> true
        _ * dirSafeToDelete.test(outputDir) >> true
        _ * dirSafeToDelete.test(outputDir.parentFile) >> false
        outputFiles.each {
            1 * fileSafeToDelete.test(it) >> true
        }

        !subDir.exists()
        !outputDir.exists()
        cleaner.didWork
    }

    private final File inputArtifact;
    private final File outputDir;

    public DefaultTransformOutputs(File inputArtifact, File outputDir, FileLookup fileLookup) {
        this.resolver = fileLookup.getPathToFileResolver(outputDir);
        this.inputArtifact = inputArtifact;
        this.outputDir = outputDir;
        this.resultBuilder = TransformExecutionResult.builderFor(inputArtifact, outputDir);
    }

    @Override

                    inputs.dir sources skipWhenEmpty()
                    outputs.dir "${outputDir}"
                    def outputDir = file("${outputDir}")
                    def sourceTree = files(sources).asFileTree
                    doLast {
                        outputDir.mkdirs()
                        sourceTree.visit { details ->
                            if (!details.directory) {

import java.io.File


internal
inline fun <T> DirectoryProperty.withOutputDirectory(action: (File) -> T): T =
    asFile.get().let { outputDir ->
        recreate(outputDir)
        action(outputDir)
    }


internal
fun recreate(outputDir: File) {
    outputDir.deleteRecursively()
    outputDir.mkdirs()

) {
    interface Host
}


class KotlinScriptCompilerTest : TestWithTempFiles() {

    @Test
    fun canInjectImplicitReceiver() {
        outputDir().let { outputDir ->

            compileKotlinScriptTo(
                outputDir,
                "bar()",
                scriptDefinitionFromTemplate(
                    template = TheKotlinScriptTemplate::class,

        then:
        def outputDir = dslDir.file("build/explodedWar")
        outputDir.file('index-staging.html').assertDoesNotExist()
        outputDir.file('index.html.tmp').assertDoesNotExist()
        outputDir.file('home.html').isFile()
        outputDir.file('logo.png').isFile()
        outputDir.file('products/collaboration.jpg').isFile()
        outputDir.file('WEB-INF/classes/Hello.class').isFile()

        this.inheritOutputDirs = inheritOutputDirs;
        return this;
    }

    @Override
    public File getOutputDir() {
        return outputDir;
    }

    public DefaultIdeaCompilerOutput setOutputDir(File outputDir) {
        this.outputDir = outputDir;
        return this;
    }

    @Override
    public File getTestOutputDir() {
        return testOutputDir;
    }

        } else {
            throw new GradleException(message, e);
        }
    }

    @OutputDirectory
    public File getOutputDir() {
        return outputDir;
    }

    public void setOutputDir(File outputDir) {
        this.outputDir = outputDir;
    }

    /**
     * {@inheritDoc}
     */
    @Input
    @Override
    public boolean getIgnoreFailures() {
        return ignoreFailures;
    }