*/

package org.gradle.testkit.runner.internal;

import org.gradle.testkit.runner.BuildTask;

import java.util.List;

public class GradleExecutionResult {

    private final BuildOperationParameters buildOperationParameters;
    private final String output;
    private final List<BuildTask> tasks;
    private final Throwable throwable;

    }

    private void addBuild(final Project project) {
        project.getTasks().register(BUILD_TASK_NAME, buildTask -> {
            buildTask.setDescription("Assembles and tests this project.");
            buildTask.setGroup(BUILD_GROUP);
            buildTask.dependsOn(ASSEMBLE_TASK_NAME);
            buildTask.dependsOn(CHECK_TASK_NAME);
        });
    }

    public String getOutput() {
        outputFeatureCheck.verify();
        return delegateBuildResult.getOutput();
    }

    @Override
    public List<BuildTask> getTasks() {
        return delegateBuildResult.getTasks();
    }

    @Override
    public List<BuildTask> tasks(TaskOutcome outcome) {
        return delegateBuildResult.tasks(outcome);
    }

    @Override
    public List<String> taskPaths(TaskOutcome outcome) {

 * limitations under the License.
 */

package org.gradle.testkit.runner.internal;

import org.gradle.testkit.runner.BuildTask;
import org.gradle.testkit.runner.TaskOutcome;

public class DefaultBuildTask implements BuildTask {
    private final String path;
    private final TaskOutcome outcome;

    public DefaultBuildTask(String path, TaskOutcome outcome) {
        this.path = path;

     * The returned list will be empty if no tasks were executed.
     * This can occur if the build fails early, due to a build script failing to compile for example.
     *
     * @return the build tasks
     */
    List<BuildTask> getTasks();

    /**
     * The subset of {@link #getTasks()} that had the given outcome.
     * <p>
     * The returned list is an unmodifiable view of items.

                    continue;
                }
                tasksInternal.addAllInternal(binary.getTasks());
                Task buildTask = binary.getBuildTask();
                if (buildTask != null) {
                    tasksInternal.addInternal(buildTask);
                }
            }
        }

        @Finalize

    }

    private void configureBuildNeeded(Project project) {
        project.getTasks().register(BUILD_NEEDED_TASK_NAME, buildTask -> {
            buildTask.setDescription("Assembles and tests this project and all projects it depends on.");
            buildTask.setGroup(BasePlugin.BUILD_GROUP);
            buildTask.dependsOn(BUILD_TASK_NAME);
        });
    }

    private void configureBuildDependents(Project project) {

        return tasks.getNames().stream()
            .map(tasks::findByName)
            .filter(Objects::nonNull)
            .map(task -> buildTask(owner, task))
            .collect(toList());
    }

    private static LaunchableGradleProjectTask buildTask(DefaultGradleProject owner, Task task) {
        LaunchableGradleProjectTask model = buildFromTask(new LaunchableGradleProjectTask(), owner.getProjectIdentifier(), task);

     */
    @Nullable
    Task getBuildTask();

    /**
     * Specifies the task responsible for building this component.
     */
    void setBuildTask(@Nullable Task buildTask);

    /**
     * Adds tasks required to build this component. Tasks added this way are subsequently
     * added as dependencies of this component's {@link #getBuildTask() build task}.
     */

        <title>Properties</title>
        <table>
            <thead>
                <tr>
                    <td>Name</td>
                </tr>
            </thead>
            <tr>
                <td>buildTask</td>
            </tr>
        </table>
    </section>
    <section>
        <title>Methods</title>
        <table>
            <thead>
                <tr>
                    <td>Name</td>