private void assertFoundDeadJavadocLinks(File file, String... paths) {
        assertFoundDeadLinks(paths.collect { DeadLink.forJavadoc(file, it) })
    }

    private static final class DeadLink {
        private final File file
        private final String message

        DeadLink(File file, String message) {
            this.file = file
            this.message = message
        }

        val linuxPaths =
            "-Porg.gradle.java.installations.paths=%linux.java8.oracle.64bit%,%linux.java11.openjdk.64bit%,%linux.java17.openjdk.64bit%,%linux.java21.openjdk.64bit%,%linux.java22.openjdk.64bit%,%linux.java8.openjdk.64bit%"
        val windowsPaths =

                    this@BasePublishGradleDistribution.extraParameters,
                    this@BasePublishGradleDistribution.gitUserName,
                    this@BasePublishGradleDistribution.gitUserEmail,
                    this@BasePublishGradleDistribution.triggerName,
                    this@BasePublishGradleDistribution.prepTask,
                    "checkNeedToPromote"
                )
            }
        }
    }
}

    fun Task.findTraceJson(): List<File> {
        if (this !is Test) {
            return emptyList()
        }
        // e.g. build/test-results/embeddedIntegTest/trace.json
        return listOf(project.layout.buildDirectory.file("test-results/$name/trace.json").get().asFile)
    }

    private
    fun Task.genericHtmlReports() = when (this) {
        is Reporting<*> -> listOf(this.reports["html"].outputLocation.get().asFile)

# Each automation is independent of the others.  Every time one of the `on` conditions match for
# this PR, this automations will have its `if` checked to run.  In a way, the `on` conditions
# function as an implicit first `if` for every automation in the file.

# You can define multiple automations in a .cm file, but each automation name should be unique

    when (this) {
        is KotlinClassMetadata.Class -> hasClassFlags(this::toKmClass, memberType, jvmSignature, predicate)
        is KotlinClassMetadata.FileFacade -> hasPackageFlags(this::toKmPackage, memberType, jvmSignature, predicate)
        is KotlinClassMetadata.MultiFileClassPart -> hasPackageFlags(this::toKmPackage, memberType, jvmSignature, predicate)

     * All of the sections of the documentation have working directories off of this one.
     */
    public abstract DirectoryProperty getStagingRoot();

    /**
     * The final location to place all rendered documentation.
     */
    public abstract DirectoryProperty getDocumentationRenderedRoot();

    /**
     * The collection of rendered documentation.  This is everything laid out as it would be deployed/packaged.
     */

        }.get()
    }
    val classpathManifest = tasks.register("classpathManifest", ClasspathManifest::class) {
        this.projectDependencies.from(runtimeClasspath.incoming.artifactView {
            componentFilter {
                it is ProjectComponentIdentifier
            }
        }.files)
        this.externalDependencies.from(runtimeClasspath.incoming.artifactView {
            componentFilter {

 *
 * Current implementation extracts these from the wrapper's API jars.
 * This is not correct as it should do this with the built distribution instead.
 *
 * Doing it correctly would require running a Gradle build with the full
 * distribution and extracting the generated api jar from its Gradle user home,
 * slowing down building documentation.
 *
 * All this would be so much simpler if the Kotlin extensions to the Gradle API

    val unixScript = """
mkdir -p test-splits
rm -rf test-splits/*-test-classes.properties
cat > test-splits/$action-test-classes.properties << EOL
${testClasses.joinToString("\n")}
EOL
echo "Tests to be ${action}d in this build"
cat test-splits/$action-test-classes.properties
"""

    val linesWithEcho = testClasses.joinToString("\n") { "echo $it" }

    val windowsScript = """
mkdir test-splits