}

                void captureWorkerDaemons() {
                    def workerDaemonIdentityFile = projectLayout.projectDirectory.file("$workerDaemonIdentityFileName").asFile
                    def daemonFactory = services.get(WorkerDaemonFactory)
                    workerDaemonIdentityFile << daemonFactory.clientsManager.allClients.collect { System.identityHashCode(it) }.sort().join(" ") + "\\n"

                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")
    }

            spec.from temporaryFolder.createFile('file.txt')
        } as Action<CopySpec>)

        when:
        execute(jar)

        then:
        new JarTestFixture(jar.archiveFile.get().asFile).assertContainsFile('META-INF/file.txt')
    }

        Property<Boolean> getBroken()
    }

    @InputArtifact
    abstract Provider<FileSystemLocation> getInputArtifact()

    void transform(TransformOutputs outputs) {
        def input = inputArtifact.get().asFile
        def color = parameters.color.get()
        def one = outputs.file("one")
        def outputDirectory = one.parentFile
        assert outputDirectory.directory && outputDirectory.list().length == 0

        InputFile      | 'file("inputs/input")'
        InputDirectory | 'file("inputs")'
        InputFiles     | 'files("inputs")'
        Input          | '{ layout.projectDirectory.file("inputs/input").asFile.text }'
    }


    def "can override @#inputType.simpleName with @Internal"() {
        buildFile << """
            class InputBaseTask extends BaseTask {
                @${inputType.name} def input

                @OutputFile
                abstract RegularFileProperty getOutputFile()

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

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

                        def outputDir = outputDirectory.get().asFile
                        fs.delete { delete(outputDir) }
                        outputDir.mkdirs()
                    }
                    changes.getFileChanges(inputDirectory).each { change ->
                        File outputFile = new File(outputDirectory.get().asFile, change.normalizedPath)

    @TaskAction
    fun updateVersions() {
        val currentReleasedVersionValue = currentReleasedVersion.get()
        val releasedVersionsFileObject = releasedVersionsFile.get().asFile

        updateReleasedVersionFile(releasedVersionsFileObject, currentReleasedVersionValue)
    }

    companion object {

        private

    def setup() {
        Directory target = Mock()
        RegularFile ignoreFile = Mock()
        1 * settings.target >> target
        1 * target.file('.gitignore') >> ignoreFile
        1 * ignoreFile.asFile >> gitignoreFile
    }

    def "generates .gitignore file"() {
        setup:
        def generator = new GitIgnoreGenerator()

        when:
        generator.generate(settings, null)

        then:

                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: