def input = inputArtifact.get().asFile
                    File outputFile = outputs.file(input.name + ".xform")
                    def outputDirectory = outputFile.parentFile
                    println("Transforming \$input in output directory \$outputDirectory")
                    java.nio.file.Files.copy(input.toPath(), outputFile.toPath())
                }
            }

            dependencies {

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

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

        then:
        args == [objectFileFlag + outputFile.absoluteFile]
    }

                @InputFiles
                abstract ConfigurableFileCollection getSources()

                @OutputFile
                abstract RegularFileProperty getOutputFile()

                @TaskAction
                void doStuff() {
                    println("Running...")
                    outputFile.get().asFile.text = "executed"
                }
            }
        """
    }

    @CompileClasspath
    public abstract ConfigurableFileCollection getBaselineDistributionJars();

    @OutputFile
    public abstract RegularFileProperty getCurrentUpgradedProperties();

    @OutputFile
    public abstract RegularFileProperty getBaselineUpgradedProperties();

    @TaskAction
    public void execute() {

        zipFile.stream().forEach { entry ->
            if (entry.shouldInclude()) {
                val outputFile = outputRoot.resolve(entry.name)
                outputFile.parentFile.mkdirs()
                zipFile.getInputStream(entry).use { input ->
                    outputFile.outputStream().use { output ->
                        input.copyTo(output)
                    }
                }
            }

            task myTask {
                def inputFile = file("${inputFile.name}")
                def outputFile = file("build/output.txt")
                outputs.file(outputFile)
                inputs.file(inputFile)
                doLast {
                    outputFile.text = inputFile.text
                }
            }
        """

        inputFile.text = "input"

        outputFiles << outputDir.file("some-output.txt")

        def subDir = outputDir.createDir("subDir")
        outputFiles << subDir.file("in-subdir.txt")

        def outputFile = temporaryFolder.createFile("output.txt")
        outputFiles << outputFile

        outputFiles.each {
            it << "output ${it.name}"
        }

        def overlappingFile = subDir.file("overlap")
        overlappingFile << "overlapping file"

            properties.setProperty(IMPLEMENTATION_CLASSPATH_PROP_KEY, implementationClasspath());
        }

        File outputFile = new File(getOutputDirectory().get().getAsFile(), METADATA_FILE_NAME);
        saveProperties(properties, outputFile);
    }

    private String implementationClasspath() {
        StringBuilder implementationClasspath = new StringBuilder();

            import ${DefaultTask.name}
            import ${RegularFileProperty.name}
            import ${TaskAction.name}
            import ${OutputFile.name}

            open class ProducerTask: DefaultTask() {
                @OutputFile
                val outFile: RegularFileProperty = project.objects.fileProperty()

                @TaskAction
                fun run() {

    }

    public static class TaskWithOutputFile extends TaskWithAction {
        File outputFile;

        @Inject
        public TaskWithOutputFile(File outputFile) {
            this.outputFile = outputFile;
        }

        @OutputFile
        public File getOutputFile() {
            return outputFile;
        }
    }

    public static class TaskWithOutputFiles extends TaskWithAction {