}
		// N.B. Don't check the task type. Empty string is a valid task type.
		v.tasks[t.ID] = t.Type
	case trace.EventTaskEnd:
		// Validate task end.
		// We can see a task end without a begin, so ignore a task without information.
		// Instead, if we've seen the task begin, just make sure the task end lines up.
		t := ev.Task()
		if typ, ok := v.tasks[t.ID]; ok {
			if t.Type != typ {

            ${repositoriesBlockFor(repos)}

            dependencies {
                implementation 'thing:lib:1.+'
            }

            task resolve1(type: ShowFilesTask) {
                inFiles.from(configurations.implementation)
            }
            task resolve2(type: ShowFilesTask) {
                inFiles.from(configurations.implementation)
            }
        """

    def "broken symlink not produced by task is ignored"() {
        given:
        def input = file("input.txt").createFile()
        def outputDirectory = file("output")

        def brokenLink = outputDirectory.file('link').createLink("broken")
        assert !brokenLink.exists()

        buildFile << """
            task copy(type: Copy) {
                from '${input.name}'

            ));
    }

    private static boolean isEnabled(Node node) {
        if (node instanceof LocalTaskNode) {
            TaskInternal task = ((LocalTaskNode) node).getTask();
            return task.getOnlyIf().isSatisfiedBy(task);
        }
        return false;
    }

    // In a perfect world, the consumer should depend on the producer.

                .run()
        }

        then:
        events.operations.size() == 10
        events.trees.size() == 2
        events.operation("Task :a:compileJava")
        def task = events.operation("Task :resolve")
        task.child("Download ${modules.projectB.pom.uri}").assertIsDownload(modules.projectB.pom)

import static org.gradle.internal.cc.impl.fixtures.ExternalProcessFixture.stringArrayExecute

class ProcessInTaskIntegrationTest extends AbstractProcessIntegrationTest {
    def "using #snippetsFactory.summary in task configuration is a problem"() {
        given:
        def snippets = snippetsFactory.newSnippets(execOperationsFixture)
        testDirectory.file("buildSrc/src/main/java/SneakyTask.java") << """

For example, you may want to set the input source files of a task based on the source directories property of an extension, but the extension property value isn't known until the build script or some other plugin configures them.
2. *Automatic Task Dependency Management:* Connects output of one task to input of another, automatically determining task dependencies.
Property instances carry information about which task, if any, produces their value.

        description                 | action
        "empty array of task names" | { BuildActionExecuter b -> b.forTasks() }
        "empty list of task names"  | { BuildActionExecuter b -> b.forTasks([]) }
    }

    def "#description means run default tasks when they are defined"() {
        file('build.gradle') << """
            defaultTasks = ["thing"]

            task thing { }
        """

        when:

    }

    @Issue("https://github.com/gradle/gradle/issues/13333")
    def "absent #operator orElse #orElseKind used as task input"() {

        assumeFalse(
            'task dependency inference for orElse(taskOutput) not implemented yet!',
            orElseKind == 'task output'
        )

        given:
        def configurationCache = newConfigurationCacheFixture()
        buildKotlinFile """

            throw problemsService.getInternalReporter().throwing(spec -> {
                spec.id("missing-task-name", "Missing task name", GradleCoreProblemGroup.taskSelection());
                String message = String.format("Cannot locate %s that match '%s'. The path should include a task name (for example %s).", type, name, examplePaths());
                configureProblem(spec, message, name, new TaskSelectionException(message));