def binDir = file("$buildDir/bin")
                doLast {
                    assert mainGroovyDestDir.get().asFile == compileGroovyDestinationDir.get().asFile
                    assert mainGroovyDestDir.get().asFile == binDir
                }
            }
        '''

        expect:
        succeeds 'assertDirectoriesAreEquals'
    }

    @get:InputArtifact
    abstract val input: Provider<FileSystemLocation>

    override
    fun transform(outputs: TransformOutputs) {
        val outputDir = outputs.dir("${input.get().asFile.name}.loc")
        println("Running transform on ${input.get().asFile.name}, incremental: ${inputChanges.isIncremental}")
        inputChanges.getFileChanges(input).forEach { change ->          // <2>
            val changedFile = change.file

                @Inject abstract InputChanges getInputChanges()

                @Override
                void transform(TransformOutputs outputs) {
                    def input = inputArtifact.get().asFile
                    println "processing [\${input.name}]"
                    def output = outputs.file("\${input.name}.\${parameters.targetColor.get()}")

            @Override
            void execute(ExecSpec execSpec) {
                execSpec.executable = buildBuilderInstall.file("bin/build-builder").get().asFile
                execSpec.workingDir = generatedDir.get().asFile
                execSpec.args = resolvedArgs
            }
        })
    }

        writeFile(value.asFile)
    }

    override suspend fun ReadContext.decode(): Directory {
        return fileFactory.dir(readFile())
    }
}


class RegularFileCodec(private val fileFactory: FileFactory) : Codec<RegularFile> {
    override suspend fun WriteContext.encode(value: RegularFile) {
        writeFile(value.asFile)
    }

                @OutputFile
                final RegularFileProperty outFile = project.objects.fileProperty()

                @TaskAction
                def run() {
                    outFile.get().asFile.text = "content"
                }
            }
        """
    }

    @Override
    boolean nestedGetterIsFinal() {
        true
    }

    @Override
    void taskWithNestedBeanDefinition() {

            throw ResourceExceptions.readFailed(displayName, e);
        }
    }

    @Override
    public File asFile(String charset) {
        throw new UnsupportedOperationException("Cannot create file for char source " + charSource);
    }

    @Override
    public File asFile() {
        throw new UnsupportedOperationException("Cannot create file for char source " + charSource);
    }

    @Override

        } finally {
            reader.close()
        }
    }

    def "read as file"() {
        expect:
        resource.asFile().text == "contents"
    }

    def "read as file with different encoding"() {
        expect:
        resource.asFile(Charsets.UTF_16.name()).getText(Charsets.UTF_16.name()) == "contents"
    }

        link instanceof LinkExecutable
        link.linkedFile.get().asFile == projectDir.file("build/exe/$exeDir" + OperatingSystem.current().getExecutableName("test_app"))

        def install = project.tasks[installTask]
        install instanceof InstallExecutable
        install.installDirectory.get().asFile == projectDir.file("build/install/$exeDir")

        where:

    @TaskAction
    fun mergeUpgradedProperties() {
        val mergedUpgradedProperties = mergeProperties()
        if (mergedUpgradedProperties.isEmpty) {
            upgradedProperties.asFile.get().delete()
        } else {
            upgradedProperties.asFile.get().writer().use { Gson().toJson(mergedUpgradedProperties, it) }
        }
    }

    private
    fun mergeProperties(): JsonArray {
        val merged = JsonArray()