// 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'

                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
            }

                mutableModel.layout.buildDirectory.finalizeValue()
                ProjectWithWork(project.projectPath, mutableModel.projectDir, mutableModel.buildFile, mutableModel.layout.buildDirectory.asFile.get(), mutableModel.normalization.computeCachedState())
            } else {
                ProjectWithNoWork(project.projectPath, mutableModel.projectDir, mutableModel.buildFile)
            }
        }
    }

                    layout.buildDirectory.file("overlap/\$fileName")
                }

                @TaskAction
                void generate() {
                    outputFile.get().asFile.text = message
                }
            }

            @CacheableTask
            class LocalStateDirectoryTask extends DefaultTask {
                @LocalState

        expect:
        def module = registry.getModule("gradle-some-module")
        module.implementationClasspath.asFiles == [classesDir, resourcesDir, staticResourcesDir]
        module.runtimeClasspath.asFiles == [externalRuntimeDep]

        def dep = registry.getExternalModule("dep")
        dep.implementationClasspath.asFiles == [externalRuntimeDep]
    }

        then:
        cachedClasspath.asFiles == [cachedFile]
        cachedFile.assertIsFile()

        and:
        1 * fileAccessTimeJournal.setLastAccessTime(cachedFile.parentFile, _)
        0 * fileAccessTimeJournal._

        when:
        def cachedClasspath2 = transformer.transform(classpath, BuildLogic)

        then:
        cachedClasspath2.asFiles == [cachedFile]

        and: