result.assertTasksExecuted([":a", ":b"])
        result.assertTasksExecuted(":a", ":b", ":a", [":a", ":b"], ":b")

        and:
        result.assertTasksExecutedInOrder(":a", ":b")
        result.assertTasksExecutedInOrder([":a", ":b"])

        and:
        result.assertTaskExecuted(':a')
        result.assertTaskExecuted(':b')
        result.assertTaskNotExecuted(':c')

        and:

            it.model(BuildEnvironment)
                .forTasks(new String[0])
                .get()
        }

        then:
        model != null
        result.assertTasksExecutedInOrder()
    }

    }
}
dependencies { deps files('b.jar') { builtBy jar } }
artifacts { archives otherJar }
'''

        when:
        run("doStuff")

        then:
        result.assertTasksExecutedInOrder(any(':b:jar', ':b:otherJar'), ':a:doStuff')
    }

        buildFile << """
            task someOtherTask
            assemble.dependsOn someOtherTask
        """

        when:
        run "assemble"

        then:
        result.assertTasksExecutedInOrder(":someOtherTask", ":assemble")
    }

    def "does not do anything when the project is empty" () {
        when:
        run "assemble"

        then:

                dependencies {
                    compile project(':a')
                }
            }
"""

        expect:
        succeeds("b:checkDeps")
        result.assertTasksExecutedInOrder(":a:jar", ":b:checkDeps")
        resolve.expectGraph {
            root(":b", "test:b:") {
                project(":a", "test:a:") {
                    artifact(name: "thing", fileName: "lib1.jar")

     * and an explanation of their usage.  Defaults to a {@link TaskOrderSpecs#exact(Object[])} assertion.
     */
    ExecutionResult assertTasksExecutedInOrder(Object... taskPaths);

    /**
     * Asserts that exactly the given set of tasks have been executed in any order.
     */
    ExecutionResult assertTasksExecuted(Object... taskPaths);

    /**

        }

        @Override
        public ExecutionResult assertTasksExecutedInOrder(Object... taskPaths) {
            Set<String> expected = TaskOrderSpecs.exact(taskPaths).getTasks();
            assertTasksExecuted(expected);
            assertTaskOrder(taskPaths);
            outputResult.assertTasksExecutedInOrder(taskPaths);
            return this;
        }

        @Override

        executer.expectDeprecationWarnings(2);
        usingBuildFile(childBuildFile).usingSettingsFile(relocatedSettingsFile).withTasks("do-stuff").run().assertTasksExecutedInOrder(":child:do-stuff");
    }

    @Test
    public void multiProjectBuildCanHaveAllProjectsAsChildrenOfSettingsDir() {
        TestFile settingsFile = testFile("settings.gradle");

            task bar(dependsOn: ":api:foo")
        """

        when:
        run("impl:bar")

        then:
        fixture.assertProjectsConfigured(":", ":impl", ":api")
        result.assertTasksExecutedInOrder(":api:foo", ":impl:bar")
    }

    def "supports buildSrc"() {
        file("buildSrc/src/main/java/FooTask.java") << """
            import org.gradle.api.DefaultTask;

        if (tasks == null) {
            tasks = new LinkedHashSet<>(grepTasks(TASK_PATTERN));
        }
        return tasks;
    }

    @Override
    public ExecutionResult assertTasksExecutedInOrder(Object... taskPaths) {
        Set<String> allTasks = TaskOrderSpecs.exact(taskPaths).getTasks();
        assertTasksExecuted(allTasks);
        assertTaskOrder(taskPaths);
        return this;
    }