abstract Provider<FileSystemLocation> getInputArtifact()

                    void transform(TransformOutputs outputs) {
                        def input = inputArtifact.get().asFile
                        ${server.callFromBuildUsingExpression("input.name")}
                        if (input.name.startsWith("bad")) {
                            throw new RuntimeException("Transform Failure: " + input.name)

        delegate.convention

    override fun getLogger(): Logger =
        delegate.logger

    @Deprecated("Use layout.buildDirectory instead", ReplaceWith("layout.buildDirectory.get().asFile"))
    override fun getBuildDir(): File =
        @Suppress("DEPRECATION")
        delegate.buildDir

    override fun getAnt(): AntBuilder =
        delegate.ant

    override fun getVersion(): Any =

// Publications for the docs subproject:

configurations {
    gradleFullDocsElements {
        // TODO: This breaks the provider
        outgoing.artifact(project.gradleDocumentation.getDocumentationRenderedRoot().get().asFile) {
            builtBy 'docs'
        }
    }
}

tasks.named("check") {
    dependsOn(tasks.named('checkstyleApi'))
}

                    @get:Input
                    val propertyName: Property<String>
                }

                override fun obtain(): String? = parameters.run {
                    propertiesFile.get().asFile.takeIf { it.isFile }?.inputStream()?.use {
                        java.util.Properties().apply { load(it) }
                    }?.get(propertyName.get()) as String?
                }
            }

                    def buildDirectory = projectLayout.buildDirectory
                    inputFiles.files.each { File inputFile ->
                        def outputFile = buildDirectory.file(inputFile.name + ".out").get().asFile
                        GFileUtils.copyFile(inputFile, outputFile)
                    }
                }
            }
            allprojects {
                apply plugin: 'java-library'

            abstract class FooToBar implements TransformAction<TransformParameters.None> {
                @Override
                void transform(TransformOutputs outputs) {
                    def input = inputArtifact.get().asFile
                    outputs.dir(input.name)
                }
            }
        """

        when:
        repositoryInteractions {
            'org:test:1.0' {
                expectGetMetadata()

                options.headerOutputDirectory.set(provider { null })
                options.fork = true
                options.forkOptions.executable = customJavaLauncher.executablePath.asFile.absolutePath
                options.forkOptions.jvmArgumentProviders.add(new EcjClasspathProvider(configurations.ecj))
            }
        """

        when:

        when (val parameters = obtainedValue.valueSourceParameters) {
            is FileContentValueSource.Parameters -> {
                parameters.file.orNull?.asFile?.let { file ->
                    // TODO - consider the potential race condition in computing the hash code here
                    captureFile(file)
                    reportUniqueFileInput(file)
                }

            }

            def zip = tasks.register("zip") {
              def zipFile = layout.buildDirectory.file("zip.txt")
              outputs.file zipFile
              doLast { zipFile.get().asFile.text = "bar" }
              dependsOn cleanZip
            }

            def integTest = tasks.register("integTest") {
              finalizedBy finalizer
            }

    @InputArtifact
    abstract Provider<FileSystemLocation> getInputArtifact()

    void transform(TransformOutputs outputs) {
        def output = outputs.file("transformed-" + inputArtifact.get().asFile.name)
        output << "transformed"
    }
}

dependencies {
    compile files('test-lib.jar')
    compile project(':lib')
    compile project(':ui')
    compile 'org:test:1.0'