this.baseClasses.addAll(baseClasses);
    }

    public void taskName(Pattern expression) {
        taskNames.add(expression);
    }

    public void taskName(String expression) {
        taskNames.add(Pattern.compile(expression));
    }

    public void setTaskNames(Collection<Pattern> expressions) {
        taskNames.clear();
        taskNames.addAll(expressions);
    }

    public Set<String> getBaseClasses() {

 */
public class GradleDistroTestTask extends VagrantShellTask {

    private String taskName;
    private String testClass;
    private List<String> extraArgs = new ArrayList<>();

    public void setTaskName(String taskName) {
        this.taskName = taskName;
    }

    @Input
    public String getTaskName() {
        return taskName;
    }

        String taskName = "copy" + camelProjectName + "Metadata";
        project.getTasks().register(taskName, Copy.class, copy -> {
            copy.into(outputDir);
            copy.from(pluginProject.getTasks().named("pluginProperties"));
            copy.from(pluginProject.file("src/main/plugin-metadata"));
        });

        Map<String, Object> map = Map.of("builtBy", taskName);

            t.setDirMode(0750);
        });
    }

    private static String archiveTaskToSubprojectName(String taskName) {
        return archiveToSubprojectName(taskName).substring("build".length() + 1);
    }

    private static String archiveToSubprojectName(String taskName) {
        return taskName.replaceAll("[A-Z]", "-$0").toLowerCase();
    }

     */
    public static Provider<RestIntegTestTask> registerTestTask(Project project, SourceSet sourceSet, String taskName) {
        // lazily create the test task
        return project.getTasks().register(taskName, RestIntegTestTask.class, testTask -> {
            testTask.setGroup(JavaBasePlugin.VERIFICATION_GROUP);

            features {
                publishBuildStatusToGithub(model)
            }

            val performanceResultsDir = "perf-results"
            val performanceProjectName = "performance"

            val taskName =
                if (performanceTestSpec.type == PerformanceTestType.FLAKINESS_DETECTION) {
                    "performanceTestFlakinessReport"
                } else {
                    "performanceTestReport"

    if (plan is FailedPlan) return plan.result

    // Connect TCP asynchronously.
    tcpConnectsInFlight += plan
    val taskName = "$okHttpName connect ${routePlanner.address.url.redact()}"
    taskRunner.newQueue().schedule(
      object : Task(taskName) {
        override fun runOnce(): Long {
          val connectResult =
            try {
              plan.connectTcp()

    listOf("install", "installAll")
        .flatMap { listOf(":distributions-full:$it", "distributions-full:$it", it) }
        .any(gradle.startParameter.taskNames::contains)

fun isRunningDocsTestTask() =
    setOf(":docs:docsTest", "docs:docsTest")
        .any(gradle.startParameter.taskNames::contains)


/**
 * Returns a new provider that takes its value from at most one

    @TaskAction
    fun generateSubprojectsInfo() {
        subprojectsJson.asFile.writeText(generateSubprojectsJson())
    }

    companion object {
        internal
        const val TASK_NAME = "generateSubprojectsInfo"
    }

public class SplitPackagesAuditPrecommitPlugin extends PrecommitPlugin {
    public static final String TASK_NAME = "splitPackagesAudit";

    @Override
    public TaskProvider<? extends Task> createTask(Project project) {
        TaskProvider<SplitPackagesAuditTask> task = project.getTasks().register(TASK_NAME, SplitPackagesAuditTask.class);
        task.configure(t -> {