* A task that is a lifecycle.
 * <p>
 * <strong>NOTE:</strong> This class is not part of any public api and can be changed or deleted without prior notice.
 *
 * @since 3.0
 */
public final class LifecycleTask extends Task {
    public LifecycleTask(String lifecyclePhase) {
        super(lifecyclePhase);
    }

        when:
        element.builtBy(dependedOn1)
        element.setBuildTask(lifecycleTask)
        element.builtBy(dependedOn2)

        then:
        element.getBuildDependencies().getDependencies(Stub(Task)) == [lifecycleTask] as Set

        and:
        lifecycleTask.getTaskDependencies().getDependencies(lifecycleTask) == [dependedOn1, dependedOn2] as Set
    }

    }

    protected void onApply(Project target) {
    }

    protected void addWorkspace(final IdeWorkspace workspace) {
        lifecycleTask.configure(new Action<Task>() {
            @Override
            public void execute(Task lifecycleTask) {
                lifecycleTask.doLast(new Action<Task>() {
                    @Override
                    public void execute(Task task) {

 * it checks the plugins *applied to* the current build.
 */
gradle.beforeProject {
    val lifecycleTask = project.tasks.register("validateExternalPlugins")
    project.plugins.configureEach { configurePluginValidation(project, lifecycleTask, javaClass) }
}

fun configurePluginValidation(
    project: Project,
    lifecycleTask: TaskProvider<Task>,
    pluginClass: Class<*>
) {

import org.apache.maven.execution.MavenSession;
import org.apache.maven.lifecycle.internal.DefaultLifecycleTaskSegmentCalculator;
import org.apache.maven.lifecycle.internal.GoalTask;
import org.apache.maven.lifecycle.internal.LifecycleTask;
import org.apache.maven.lifecycle.internal.TaskSegment;
import org.apache.maven.plugin.InvalidPluginDescriptorException;
import org.apache.maven.plugin.MojoNotFoundException;

        given:
        def tasks = Mock(NativeExecutableBinarySpec.TasksCollection)
        def lifecycleTask = Mock(InstallExecutable)
        when:
        exeBinary.tasks >> tasks
        tasks.withType(InstallExecutable) >> domainObjectSet(lifecycleTask)
        lifecycleTask.path >> "lifecycle-task-path"
        exe.projectPath >> ":project-path"

        then:

        given:
        def binary = sharedLibrary
        binary.sharedLibraryFile = sharedLibraryFile
        binary.sharedLibraryLinkFile = sharedLibraryLinkFile
        def lifecycleTask = Stub(Task)
        binary.setBuildTask(lifecycleTask)
        binary.builtBy(Stub(Task))

        and: "has at least one header exporting source set"
        final headerDir = tmpDir.createDir("headerDir")

        binary.staticLibraryFile == outputFile
    }

    def "can convert binary to a native dependency"() {
        final binary = staticLibrary
        given:
        def lifecycleTask = Stub(Task)
        binary.buildTask = lifecycleTask
        binary.builtBy(Stub(Task))

        and:
        binary.staticLibraryFile = outputFile

        and:
        final headerDir = tmpDir.createDir("headerDir")

            it.targetPlatform.get() == testExecutable.targetPlatform
            it.linkerArgs.get() == testExecutable.linker.args
        }

        and:
        def lifecycleTask = project.tasks.testExecutable
        lifecycleTask TaskDependencyMatchers.dependsOn("linkTestExecutable")

        and:
        project.tasks.installTestExecutable instanceof InstallExecutable
    }

 *
 * <strong>NOTE:</strong> This class is not part of any public api and can be changed or deleted without prior notice.
 *
 * @since 3.0
 */
public final class TaskSegment {

    // Can be both "LifeCycleTask" (clean/install) and "GoalTask" (org.mortbay.jetty:maven-jetty-plugin:6.1.19:run)

    private final List<Task> tasks;

    private final boolean aggregating;

    public TaskSegment(boolean aggregating) {