abstract RegularFileProperty getInputFile()

                @Override
                Iterable<String> asArguments() {
                    return ["-Dinput.file=\${inputFile.get().asFile.absolutePath}".toString()]
                }
            }

            abstract class MyApplicationCommandLineArguments implements CommandLineArgumentProvider {
                @OutputFile

    def setup() {
        Directory target = Mock()
        RegularFile attributesFile = Mock()
        1 * settings.target >> target
        1 * target.file('.gitattributes') >> attributesFile
        1 * attributesFile.asFile >> gitattributesFile
    }

    def "generates .gitattributes file"() {
        setup:
        def generator = new GitAttributesGenerator()

        when:
        generator.generate(settings, null)

        }
        return systemProperties
    }

    private
    fun getStudioHome(): String {
        if (autoDownloadAndroidStudio) {
            val androidStudioPath = studioInstallation.studioInstallLocation.asFile.get().absolutePath
            return "-Dstudio.home=$androidStudioPath"
        } else if (androidStudioHome.isPresent) {
            return "-Dstudio.home=${androidStudioHome.get()}"
        }

                name = moduleIdentity.baseName.map { "${project.group}:$it"}
            }
        }
    }
    repositories {
        maven {
            name = "test"
            url = testRepoLocation.get().asFile.toURI()
        }
    }
}

val testRepoElements = configurations.consumable("testRepoElements") {
    outgoing.artifact(testRepoLocation) {
        builtBy( "publishMavenPublicationToTestRepository")
    }

                @OutputFile
                abstract RegularFileProperty getOutputFile()

                @TaskAction
                void doWork() {
                    getOutputFile().asFile.get().write(getMyProperty().get())
                }
            }

            def touchFsInEvaluation = provider {
                file("test").exists() ? "yes" : "no"
            }

                implementation project(':b')
            }
            task resolve(type: InputTask) {
                inValue = configurations.implementation.elements.map { files -> files.collect { it.asFile.text.toInteger() } }
                outFile = file('out.txt')
            }
        """

        given:
        configurationCacheRun(":resolve")

        when:

            def copy1 = tasks.register("copy1", Copy) {
                destinationDir = layout.buildDirectory.dir("copy1").get().asFile
                from file("copy1source.txt")
            }

            def copy2 = tasks.register("copy2", Copy) {
                destinationDir = layout.buildDirectory.dir("copy2").get().asFile
                from file("copy2source.txt")
            }

            tasks.register("reader") {

                        dep.buildDependencies(sourceJar, javadocJar)
                        dep.publicationSourcePath = cp.fileReference(sourceJar.archiveFile.get().asFile)
                        dep.publicationJavadocPath = cp.fileReference(javadocJar.archiveFile.get().asFile)
                    }
                }
            }
        """
        }

                abstract ProjectLayout getLayout()

                @TaskAction
                void generate() {
                    layout.buildDirectory.dir("some-dir").get().asFile.mkdirs()
                    layout.buildDirectory.file("some-dir/output.txt").get().asFile.text = "output"
                }
            }

            task pluralOutputs(type: PluralOutputs)
        """
        when:

    @get:PathSensitive(PathSensitivity.RELATIVE)
    abstract val apiChangesDirectory: DirectoryProperty

    protected
    fun loadChanges(): Map<File, List<AcceptedApiChange>> {
        return apiChangesDirectory.get().asFile.listFiles()
            ?.filter {
                it.name.endsWith(".json")
            }?.associate {
                it to it.readAcceptedChanges()
            }?.filterValues {