TestFile target2File = testFile('build/target2.txt')
        target1File.assertDoesNotExist()
        target2File.assertDoesNotExist()

        inTestDirectory().withTasks('ant').run().assertTasksExecutedInOrder(':initialize', ':target2', ':target1', ':ant')

        target1File.assertExists()
        target2File.assertExists()
    }

    @Test
    @ToBeFixedForConfigurationCache(because = "AntTarget task")

    }

    @Test
    void failsCompilationWhenConfigScriptIsUpdated() {
        // compilation passes with a config script that does nothing
        executer.withTasks('compileGroovy').run().assertTasksExecutedInOrder(":compileJava",":compileGroovy")

        // make sure it fails if the config script applies type checking
        file('groovycompilerconfig.groovy').assertIsFile().copyFrom(file('newgroovycompilerconfig.groovy'))

            }
            dependencies {
                implementation localGroovy()
            }
        """

        when:
        succeeds 'compileJava'

        then:
        result.assertTasksExecutedInOrder(':compileGroovy', ':compileJava')

        where:
        configurationStyle | setup
        'lazy'             | "tasks.named('compileJava') { classpath += files(sourceSets.main.groovy.classesDirectory) }"

            dependencies {
                implementation("org.scala-lang:scala-library:2.11.12")
            }
        """

        when:
        succeeds 'compileJava'

        then:
        result.assertTasksExecutedInOrder(':compileScala', ':compileJava')

        where:
        configurationStyle | setup
        'lazy'             | "tasks.named('compileJava') { classpath += files(sourceSets.main.scala.classesDirectory) }"

        delegate.assertNotPostBuildOutput(expectedOutput);
        return this;
    }

    @Override
    public ExecutionResult assertTasksExecutedInOrder(Object... taskPaths) {
        delegate.assertTasksExecutedInOrder(taskPaths);
        return this;
    }

    @Override
    public ExecutionResult assertTasksExecuted(Object... taskPaths) {

            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:

     * 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);

    /**