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);

	}
	if cfg.BuildMSan {
		appendSetting("-msan", "true")
	}
	// N.B. -pgo added later by setPGOProfilePath.
	if cfg.BuildRace {
		appendSetting("-race", "true")
	}
	if tags := cfg.BuildContext.BuildTags; len(tags) > 0 {
		appendSetting("-tags", strings.Join(tags, ","))
	}
	if cfg.BuildTrimpath {
		appendSetting("-trimpath", "true")
	}
	if p.DefaultGODEBUG != "" {

package comment, and only in package main or *_test.go files.

Support for other known directives may be added in the future.

This analyzer does not check //go:build, which is handled by the
buildtag analyzer.
`

var Analyzer = &analysis.Analyzer{
	Name: "directive",
	Doc:  Doc,
	URL:  "https://pkg.go.dev/golang.org/x/tools/go/analysis/passes/directive",
	Run:  runDirective,
}

     */
    @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>

        }

        @Override
        String getOutput() {
            return delegate.output
        }

        @Override
        List<BuildTask> getTasks() {
            return delegate.tasks
        }

        @Override
        List<BuildTask> tasks(TaskOutcome outcome) {
            return delegate.tasks(outcome)
        }

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

        when:
        buildFile << withSimpleComponentBinaries()
        buildFile << '''
            model {
                tasks {
                    tellTaskName(Task) {
                        doLast {
                            def binaries = $.binaries
                            assert binaries.sampleLibBinary.buildTask instanceof Task

    }

    private void withArgs(List<String> args) {
        buildArgs = args as List
    }

    private void checkDependencies() {
        resolve.prepare()
        execute(buildA, ":checkDeps", buildArgs)
    }

    private void checkDependenciesFails() {
        resolve.prepare()
        fails(buildA, ":checkDeps", buildArgs)
    }

 * limitations under the License.
 */

package org.gradle.testkit.runner;

/**
 * The outcome of executing a task during a build.
 *
 * @since 2.6
 * @see BuildTask#getOutcome()
 */
public enum TaskOutcome {

    /**
     * The task executed and performed its actions without failure.
     */
    SUCCESS,

    /**

        then:
        1 * taskFactory.create("foo", DefaultTask) >> task
        1 * action.execute(task)
    }

    def "provides lifecycle task for binary"() {
        when:
        1 * binary.buildTask >> task

        then:
        tasks.build == task
    }

    def "returns null for missing single task with type"() {
        expect:
        tasks.findSingleTaskWithType(Copy) == null
    }