println("Create ${path}")
                }
            }
            class SomeSubTask extends SomeTask {
                SomeSubTask() {
                    println("Create subtask ${path}")
                }
            }
            class SomeOtherTask extends DefaultTask {
                SomeOtherTask() {
                    println("Create ${path}")
                }
            }

               println "Configure ${path}"
            }
        '''

        expect:
        succeeds "help"

        result.output.count("Create subtask :myTask") == 1
        result.output.count("Lazy 1 :myTask") == 1
        result.output.count("Lazy 2 :myTask") == 1
        result.output.count("Configure :myTask") == 1
    }

)

type traceContextKey struct{}

// NewTask creates a task instance with the type taskType and returns
// it along with a Context that carries the task.
// If the input context contains a task, the new task is its subtask.
//
// The taskType is used to classify task instances. Analysis tools
// like the Go execution tracer may assume there are only a bounded
// number of unique task types in the system.
//

    def createsDetailsForTaskInSubProject() {
        task.project >> subproject
        task.path >> ':sub:path'
        project.relativeProjectPath(':sub:path') >> 'sub:task'

        expect:
        def details = factory.create(task)
        details.path == Path.path('sub:task')
    }

    def createsDetailsForTaskInOtherProject() {
        Project other = Mock()
        task.project >> other
        task.path >> ':other:task'

    def "merges the tasks with a given name from each project into a single task"() {
        TaskDetails task1 = taskDetails(':task')
        TaskDetails task2 = taskDetails(':other')
        TaskDetails task3 = taskDetails(':sub:task')
        _ * task1.findTask(_) >> Mock(Task)
        _ * task2.findTask(_) >> Mock(Task)
        _ * task3.findTask(_) >> Mock(Task)

        TaskReportModel project1 = Mock()
        TaskReportModel project2 = Mock()

// cancelation for groups of goroutines working on subtasks of a common task.
//
// [errgroup.Group] is related to [sync.WaitGroup] but adds handling of tasks
// returning errors.
package errgroup

import (
	"context"
	"fmt"
	"sync"
)

type token struct{}

// A Group is a collection of goroutines working on subtasks that are part of
// the same overall task.
//