println "Configuring " + task.name
                bar.get()
            }

            task some { dependsOn tasks.withType(SomeTask) }
        """

        expect:
        succeeds("some")

        and:
        executed ":foo", ":baz", ":fizz", ":fuzz", ":some"
    }

    def "can lookup task created by rules"() {
        buildFile << """

    private final TaskInternal task;
    private final TaskMutator taskMutator;

    public DefaultTaskOutputs(final TaskInternal task, TaskMutator taskMutator, PropertyWalker propertyWalker, TaskDependencyFactory taskDependencyFactory, FileCollectionFactory fileCollectionFactory) {
        this.task = task;
        this.taskMutator = taskMutator;

        selector.resolveTaskName(null, null, target, "task")

        then:
        1 * taskSelector.getSelection(_, root.defaultProject, "task", true)
    }

    def "selects matching task relative to root project when absolute path is provided"() {
        def project = addProject(root, "lib")
        withIncludedBuilds()

        when:
        selector.resolveTaskName(null, null, target, ":task")

        then:

                class CustomTaskAction implements Action<Task> {
                    static Action<Task> create() {
                        return new CustomTaskAction()
                    }

                    @Override
                    void execute(Task task) {
                    }
                }
            '''

            task customTask(type: CustomTask) {

        fails "block"

        and:
        def outputLines = result.groupedOutput.task(":block").output.readLines()
        outputLines[0] == "Requesting stop of task ':block' as it has exceeded its configured timeout of 500ms."
        outputLines[1] == "Timed out task ':block' has not yet stopped."
        outputLines[outputLines.size() - 1] == "Timed out task ':block' has stopped."

        and:
        def logging = taskLogging(":block")

    }

    void taskIsNotCached(String task) {
        withBuildCache().run task
        executedAndNotSkipped(task)
        cleanBuildDir()

        withBuildCache().run task
        executedAndNotSkipped(task)
    }

    void taskIsCached(String task) {
        withBuildCache().run task
        executedAndNotSkipped(task)
        cleanBuildDir()

        withBuildCache().run task

                }
            }
            task direct { inputs.files configurations.compile }
            task fileCollection { inputs.files configurations.compile.fileCollection { true } }
            task ownDependencies { dependsOn configurations.compile.dependencies }
            task allDependencies { dependsOn configurations.compile.allDependencies }
            task incomingFiles { inputs.files configurations.compile.incoming.files }

            import org.gradle.test.Task;

            @Generated
            public class Task_Adapter {
                public static int access_get_getMaxErrors(Task self) {
                    ${getDefaultDeprecation("Task", "maxErrors")}
                    return self.getMaxErrors().getOrElse(0);
                }

                public static void access_set_setMaxErrors(Task self, int arg0) {

    def "hash set output files marks task up-to-date"() {
        buildFile << """
            class MyTask extends DefaultTask {
                @OutputFiles Set<File> out = new HashSet<File>()

                @TaskAction def exec() {
                    out.each { it.text = 'data' }
                }
            }

            task myTask(type: MyTask) {

                outputs.file(outputFile)
                doLast {
                    outputFile.text = "consumed"
                }
            }

            task a
            task b
            task c
            task d

            consumer.dependsOn(d)

            d.dependsOn(c)
            ${dependency}
            b.dependsOn(a)

            a.dependsOn(producer)
        """