void beforeExecute(Task task) { }
                void afterExecute(Task task, TaskState state) { }
            }
            def taskActionListener = new TaskActionListener() {
                void beforeActions(Task task) { }
                void afterActions(Task task) { }
            }
            $path($listener)
            task broken
        """

        when:

        ex.message == "Querying the filtered value of <prop> before <task> has completed is not supported"
    }

    Property<String> propertyWithProducer() {
        def task = Mock(Task)
        def state = Mock(TaskState)
        _ * task.toString() >> "<task>"
        _ * task.state >> state
        def owner = Stub(ModelObject)
        _ * owner.taskThatOwnsThisObject >> task

> Task :app:processTestResources NO-SOURCE
> Task :list:compileJava
> Task :list:processResources NO-SOURCE
> Task :list:classes
> Task :list:jar
> Task :utilities:compileJava
> Task :utilities:classes
> Task :utilities:jar
> Task :utilities:compileTestJava NO-SOURCE
> Task :utilities:testClasses UP-TO-DATE
> Task :utilities:test NO-SOURCE
> Task :utilities:check UP-TO-DATE
> Task :list:compileTestJava

    }

    def "does not start dependent task until all submitted work for current task is complete"() {
        given:
        buildFile << """
            task anotherParallelWorkTask(type: MultipleWorkItemTask) {
                doLast {
                    submitWorkItem("taskAction1")
                    submitWorkItem("taskAction2")
                }
            }
            task parallelWorkTask(type: MultipleWorkItemTask) {

    TestTask createTask(String name) {
        def task = TestUtil.create(temporaryFolder).createTask(TestTask, project, name)
        assertTrue(TestTask.isAssignableFrom(task.getClass()))
        return task
    }

    def "can add action to a task via Task.getActions() List"() {
        setup:
        def task = createTask("task")
        when:
        def actions = task.actions
        and:
        def action = Mock(Action)

> Task :compileJava
> Task :processResources NO-SOURCE
> Task :classes
> Task :jar
> Task :compileTestJava
> Task :processTestResources NO-SOURCE
> Task :testClasses
> Task :test
> Task :compileIntegrationTestJava
> Task :processIntegrationTestResources NO-SOURCE
> Task :integrationTestClasses
> Task :integrationTest
> Task :check

BUILD SUCCESSFUL in 0s

     * {@link TaskDependencyInternal#getDependencies(Task)}.
     */
    Set<? extends Task> getDependenciesForInternalUse(@Nullable Task task);

    TaskDependencyInternal EMPTY = new TaskDependencyContainerInternal() {
        @Override
        public Set<? extends Task> getDependenciesForInternalUse(@Nullable Task task) {
            return Collections.emptySet();

> Task :app:processResources NO-SOURCE
> Task :app:classes UP-TO-DATE
> Task :app:jar UP-TO-DATE
> Task :app:startScripts UP-TO-DATE
> Task :app:distTar UP-TO-DATE
> Task :app:distZip UP-TO-DATE
> Task :app:assemble UP-TO-DATE
> Task :app:compileTestJava UP-TO-DATE
> Task :app:processTestResources NO-SOURCE
> Task :app:testClasses UP-TO-DATE
> Task :app:test UP-TO-DATE
> Task :app:check UP-TO-DATE
> Task :app:build UP-TO-DATE

                void applyMessages(@Path("tasks.test") Task task) {
                    println "as task: \$task"
                }
                @Mutate
                void applyMessages(@Path("tasks.test") EchoTask task) {
                    println "as task subtype: \$task"
                }
                @Mutate
                void applyMessages(@Path("tasks.test") ModelElement task) {
                    println "as model element: \$task"

        when:
        task.actions.add(namedAction)
        task.actions.add(0, namedAction)
        task.doFirst(namedAction)
        task.doLast(namedAction)
        task.appendParallelSafeAction(namedAction)
        task.prependParallelSafeAction(namedAction)

        then:
        task.actions[0].displayName == "I have a name"
        task.actions[1].displayName == "I have a name"