result.assertTaskOrder(cleanFoo.fullPath, cleanBar.fullPath, clean.fullPath)
            result.assertTaskOrder(cleanBarLocal.fullPath, generateBar.fullPath, generate.fullPath)
            result.assertTaskOrder(cleanBar.fullPath, generateBar.fullPath, generate.fullPath)
            result.assertTaskOrder(cleanFoo.fullPath, generateFoo.fullPath, generate.fullPath)
        }
    }

            result.assertTaskOrder(generateFoo.fullPath, generateBar.fullPath)
            result.assertTaskOrder(generateFoo.fullPath, cleanFoo.fullPath, clean.fullPath)
            result.assertTaskOrder(packageBarSources.fullPath, cleanBar.fullPath, clean.fullPath)
            result.assertTaskOrder(generateBar.fullPath, cleanBar.fullPath, clean.fullPath)
        }
    }

        2.times {
            succeeds 'entryPoint'
            result.assertTaskOrder ':entryPoint', ':finalizerDepDep1', ':finalizerDep1', ':finalizer'
            result.assertTaskOrder ':entryPoint', ':finalizerDepDep2', ':finalizerDep2', ':finalizer'
        }
        2.times {
            fails 'entryPoint', '-PentryPoint.broken'
            result.assertTaskOrder ':entryPoint', ':finalizerDepDep1', ':finalizerDep1', ':finalizer'

        args "--parallel"
        execute(buildA, "clean", "build")

        then:
        result.assertTaskOrder(':buildB:clean', ':buildB:compileJava', ':clean', ':compileJava')

        when:
        args "--parallel"
        execute(buildA, "build", "clean")

        then:
        result.assertTaskOrder(':buildB:compileJava', ':compileJava', ':buildB:clean', ':clean')
    }

        configurationCacheRun(":resolve")

        then: // everything is up-to-date
        configurationCache.assertStateLoaded()
        result.assertTaskOrder(":additionalFile", ":resolve")
        result.assertTaskOrder(":a:producer", ":resolve")
        result.assertTaskOrder(":b:producer", ":resolve")
        result.assertTaskSkipped(":additionalFile")
        result.assertTaskSkipped(":a:producer")

        delegate.assertTaskNotExecuted(taskPath);
        return this;
    }

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

    @Override
    public ExecutionResult assertTasksSkipped(Object... taskPaths) {
        delegate.assertTasksSkipped(taskPaths);

                result.assertTaskOrder(getCleanTaskName(taskName), taskName)
            }
        }
    }

    def assertGenerationTasksRunBeforeCleanTasks() {
        [":", ":foo", ":foo:bar"].each { projectPath ->
            getGenerationTaskNames(projectPath).each { taskName ->
                result.assertTaskOrder(taskName, getCleanTaskName(taskName))
            }
        }
    }

        file("b/src/main/java/Bar.java") << "public class Bar extends Foo {}"

        when:
        args "--parallel"
        succeeds 'clean', 'build'

        then:
        result.assertTaskOrder(
            any(
                exact(':a:clean', ':a:compileJava'),
                exact(':b:clean', ':b:compileJava'),
                exact(':a:compileJava', ':b:compileJava')
            )
        )

        }
    }

    private int configured(def build) {
        result.output.count("Configured " + build)
    }

    private void executedInOrder(String... tasks) {
        result.assertTaskOrder(tasks)
    }

        when:
        configurationCacheRun 'clean', 'compileJava'

        then:
        configurationCache.assertStateLoaded()

        and:
        result.assertTaskOrder(':lib:compileJava', ':util:compileJava', ':compileJava')

        where:
        order << ['lib', 'util'].permutations()
    }

    private static withDevelocityPlugin(TestFile settingsDir) {