String compileTaskName = mainFeature.getSourceSet().getCompileTaskName("scala");
        final TaskProvider<AbstractScalaCompile> compileScala = project.getTasks().withType(AbstractScalaCompile.class).named(compileTaskName);
        final Provider<RegularFile> compileScalaMapping = project.getLayout().getBuildDirectory().file("tmp/scala/compilerAnalysis/" + compileTaskName + ".mapping");

                public String getTestProject() {
                    return mostRecent.getTestProject();
                }

                @Override
                public List<String> getTasks() {
                    return mostRecent.getTasks();
                }

                @Override
                public List<String> getCleanTasks() {
                    return mostRecent.getCleanTasks();
                }

        GenerateWorkspaceSettingsFileTask workspaceSettingsFileTask = project.getTasks().create("xcodeProjectWorkspaceSettings", GenerateWorkspaceSettingsFileTask.class);
        workspaceSettingsFileTask.setOutputFile(new File(xcodeProjectPackageDir, "project.xcworkspace/xcshareddata/WorkspaceSettings.xcsettings"));

        GenerateXcodeProjectFileTask projectFileTask = project.getTasks().create("xcodeProject", GenerateXcodeProjectFileTask.class);

    @Override
    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

        }
    }

    private static String getTasks(PerformanceTestHistory testHistory) {
        PerformanceTestExecution performanceTestExecution = getExecution(testHistory);
        if (performanceTestExecution == null || performanceTestExecution.getTasks() == null) {
            return "";
        }
        return Joiner.on(" ").join(performanceTestExecution.getTasks());
    }

            import ${Project.name};
            import ${Plugin.name};

            public class SomePlugin implements Plugin<Project> {
                public void apply(Project project) {
                    project.getTasks().register("producer", ProducerTask.class, t -> {
                        t.getOutFile().set(project.getLayout().getBuildDirectory().file("intermediate.txt"));
                    });
                }
            }

     * 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.
     * The returned list will be empty if no tasks were executed with the given outcome.
     *

                        Action<? super TaskB> actionB = LambdaPlugin::foo;

                        project.getTasks().register("a", TaskA.class, task -> task.doLast(a -> actionA.execute((TaskA) a)));
                        project.getTasks().register("b", TaskB.class, task -> task.doLast(b -> actionB.execute((TaskB) b)));
                    }
                }
            """
        }

        this.aggregating = aggregating;
        this.tasks = new ArrayList<>(Arrays.asList(tasks));
    }

    @Override
    public String toString() {
        return getTasks().toString();
    }

    public List<Task> getTasks() {
        return tasks;
    }

    public boolean isAggregating() {
        return aggregating;
    }

    // TODO Consider throwing UnsupportedSomething on hashCode/equals

public class DefaultNativeExecutableBinarySpec extends AbstractNativeBinarySpec implements NativeExecutableBinary, NativeExecutableBinarySpecInternal {
    private final DefaultTasksCollection tasks = new DefaultTasksCollection(super.getTasks());
    private final NativeInstallationSpec installation = new NativeInstallationSpec();
    private final NativeExecutableFileSpec executable = new NativeExecutableFileSpec();

    @Override