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
        }

public class UpgradePropertiesRuleSetup implements SetupRule {

    private static final String CURRENT_UPGRADED_PROPERTIES_KEY = "currentUpgradedProperties";
    private static final String BASELINE_UPGRADED_PROPERTIES_KEY = "baselineUpgradedProperties";

    private final Map<String, String> params;

    public UpgradePropertiesRuleSetup(Map<String, String> params) {
        this.params = params;
    }

    @Override

import jetbrains.buildServer.configs.kotlin.buildSteps.script
import model.CIBuildModel
import model.Stage

enum class TestSplitType(val action: String) {
    INCLUDE("include"), EXCLUDE("exclude")
}

fun prepareTestClassesStep(os: Os, type: TestSplitType, testClasses: List<String>): BuildSteps.() -> Unit {
    val action = type.action
    val unixScript = """
mkdir -p test-splits
rm -rf test-splits/*-test-classes.properties

        });
    }

    private static void overrideDokkaVersion(Project project, GradleDocumentationExtension extension) {
        Property<String> dokkaVersionOverride = extension.getKotlinDslReference().getDokkaVersionOverride();
        Property<String> defaultDokkaVersion = getDokkatooExtension(project).getVersions().getJetbrainsDokka();
        defaultDokkaVersion.set(dokkaVersionOverride.convention(defaultDokkaVersion.get()));

    }

    def fullyQualifyAllTypeNames(gradlebuild.docs.dsl.source.model.ClassMetaData classMetaData, TypeNameResolver resolver) {
        try {
            classMetaData.resolveTypes(new Transformer<String, String>(){
                String transform(String i) {
                    return resolver.resolve(i, classMetaData)
                }
            })
            classMetaData.visitTypes(new Action<gradlebuild.docs.dsl.source.model.TypeMetaData>() {

    lateinit var projectDir: Path

    private
    val implementation = PackageListGenerator.Implementation(DEFAULT_EXCLUDES_FOR_TEST)

    private
    fun getRelocatedPackages(files: Sequence<Path>): List<String> = mutableListOf<String>().apply {
        implementation.collectPackages(files.toList()).dump(false, this::add)
    }

    @Test
    fun `generates a curated list of package prefixes from directories`() {

        checkXrefLinksInUserManualAreValid(layout, tasks, extension);
    }

    public static List<String> getDefaultExcludedPackages() {
        // TODO: This should be configured via the extension vs hardcoded in the plugin
        List<String> excludedPackages = new ArrayList<>();
        // These are part of the API, but not the DSL
        excludedPackages.add("org.gradle.tooling.**");

    NullabilityBreakingChangesRule(Map<String, Object> params) {
        super(params)
    }

    @Override
    Violation maybeViolation(JApiCompatibility member) {

        if (isNewOrRemoved(member)) {
            return null
        }

        List<String> warnings = []
        List<String> errors = []

 * to the build service.
 */
interface TestFilesCleanupBuildServiceRootExtension {
    val projectStates: MapProperty<String, TestFilesCleanupProjectState>

    /**
     * Key is the path of a task, value is the possible report dirs it generates.
     */
    val taskPathToReports: MapProperty<String, List<File>>

        value = [
            "master,  promoteMilestone",
            "release, promoteReleaseMilestone"
        ]
    )
    fun `publish milestone build type runs three gradle invocations`(branch: String, promoteTaskName: String) {
        val model = setupModelFor(branch)
        val nightlySnapshot = model.findBuildTypeByName("Release - Milestone")

        val steps = nightlySnapshot.steps.items
        assertEquals(3, steps.size)