private final String taskName;

        public TaskPathSpec(ProjectInternal targetProject, String taskName) {
            this.targetProject = targetProject;
            this.taskName = taskName;
        }

        @Override
        public boolean isSatisfiedBy(Task element) {
            if (!element.getName().equals(taskName)) {
                return true;
            }

{% for section_name, section_content in external_links.items() %}

## {{ section_name }}

{% for lang_name, lang_content in section_content.items() %}

### {{ lang_name }}

{% for item in lang_content %}

fun stageTriggerUuid(model: CIBuildModel, stage: Stage) = stageTriggerUuid(model, stage.stageName)

fun stageTriggerId(model: CIBuildModel, stageName: StageName) = "${model.projectId}_Stage_${stageName.id}_Trigger"

fun stageTriggerUuid(model: CIBuildModel, stageName: StageName) = "${DslContext.uuidPrefix}_${model.projectId}_Stage_${stageName.uuid}_Trigger"

import jetbrains.buildServer.configs.kotlin.triggers.schedule
import model.StageName
import vcsroots.gradlePromotionBranches

class PublishNightlyDocumentation(branch: VersionedSettingsBranch) : PublishGradleDistributionFullBuild(
    promotedBranch = branch.branchName,
    promoteTask = "publishBranchDocs",
    triggerName = StageName.PULL_REQUEST_FEEDBACK.uuid,
    vcsRootId = gradlePromotionBranches
) {
    init {

        if (stage.stageName !in listOf(StageName.QUICK_FEEDBACK_LINUX_ONLY, StageName.QUICK_FEEDBACK)) {
            if (topLevelFunctionalTests.size + functionalTestProjects.size > 1) {
                buildType(PartialTrigger("All Functional Tests for ${stage.stageName.stageName}", "Stage_${stage.stageName.id}_FuncTests", model, functionalTests))
            }

        buildFile << """
            sourceSets.create("mainAlt")

            ${TASK_NAME}.pluginClasspath.setFrom(sourceSets.mainAlt.runtimeClasspath)
        """
        succeeds TASK_NAME

        then:
        executedAndNotSkipped(":$TASK_NAME")

        and:
        succeeds TASK_NAME

        then:
        skipped(":$TASK_NAME")
    }

        """
    }

    def "fails when applied in build with #taskName"() {
        buildFile << """

        task $taskName {
            doLast {
                println "custom $taskName task"
            }
        }
        """

        when:
        fails(taskName)

        then:
        failure.assertHasCause("Cannot add task '$taskName' as a task with that name already exists.")
        where:

abstract class BaseSelectionException extends InvalidUserDataException implements FailureResolutionAware {
    private final String taskName;
    private final String targetName;

    public BaseSelectionException(String message, String taskName, String targetName) {
        super(message);
        this.taskName = taskName;
        this.targetName = targetName;
    }

    @Override
    public void appendResolutions(Context context) {

public interface GitRepository {
    URI getUrl();

    Ref createBranch(String branchName) throws GitAPIException;

    Ref checkout(String branchName) throws GitAPIException;

    Ref createLightWeightTag(String tagName) throws GitAPIException;

    TestFile getWorkTree();

    TestFile file(Object... path);

    RevCommit commit(String message) throws GitAPIException;

    def "can apply a plugin declared in a catalog"() {
        String taskName = 'greet'
        String message = 'Hello from plugin!'
        String pluginId = 'com.acme.greeter'
        String pluginVersion = '1.5'
        def plugin = new PluginBuilder(file("greeter"))
            .addPluginWithPrintlnTask(taskName, message, pluginId)
            .publishAs("some", "artifact", pluginVersion, pluginPortal, executer)