Map<Project, Set<Task>> allTasks;
    private final boolean includeTasks;

    public TasksFactory(boolean includeTasks) {
        this.includeTasks = includeTasks;
    }

    public void collectTasks(Project root) {
        allTasks = root.getAllTasks(true);
    }

    public Set<Task> getTasks(Project project) {
        if (includeTasks) {
            return allTasks.get(project);
        } else {

            }
        """
        buildFile << """
            task allTasks

            12.times { i ->
                project(":project\${i}") {
                    task "slowTask\${i}" {
                        doLast {
                            sleep 2000 + (1000*(i%2))
                        }
                    }

                    rootProject.allTasks.dependsOn ":project\${i}:slowTask\${i}"
                }

        when:
        factory.allTasks = [:]
        factory.allTasks.put(project, [task] as Set)
        def tasks = factory.getTasks(project)

        then:
        tasks.empty
    }

    def "returns tasks"() {
        TasksFactory factory = new TasksFactory(true)

        when:
        factory.allTasks = [:]
        factory.allTasks.put(project, [task] as Set)

        project.tasks.withType(PublishToMavenLocal).sort { it.name }
    }

    List<PublishToMavenRepository> getPublishTasks() {
        def allTasks = project.tasks.withType(PublishToMavenRepository).sort { it.name }
        allTasks.removeAll(publishLocalTasks)
        return allTasks
    }

    def "publication coordinates are live"() {
        when:
        project.group = "group"
        project.version = "version"

                        writer.close()
                    }
                }
                gradle.taskGraph.whenReady { taskGraph ->
                    taskGraph.allTasks.last().doLast {
                        if (!gradleEnvironment.exists()) {
                            throw new GradleException("could not determine if $ideCommandLineTool is using the correct environment, did $ideTaskName task run?")

        gradle.taskGraph.whenReady {
            val buildService: Provider<T> = gradle.sharedServices.registerIfAbsent("${klass.simpleName}-$rootProjectName", klass) {
                parameters.monitoredTaskPaths = allTasks.filter(taskFilter).map { if (isInBuildLogic) ":build-logic${it.path}" else it.path }.toSet()
            }
            gradle.serviceOf<BuildEventsListenerRegistry>().onTaskCompletion(buildService)

            "reason",
            "redundantKaptCheck",
            "redundantPluginAlert",
        ) -> true

        else -> false
    }
}

gradle.taskGraph.whenReady {
    allTasks.filter(unsupportedTasksPredicate).forEach { task ->
        task.notCompatibleWithConfigurationCache("Task is not compatible with the configuration cache")
    }
}

        checkCrossProjectTaskAccess(task)
        return delegate.hasTask(task)
    }

    override fun getAllTasks(): MutableList<Task> {
        val result = delegate.allTasks
        observingTasksMaybeFromOtherProjects(result)
        return result
    }

    override fun getDependencies(task: Task): MutableSet<Task> {
        checkCrossProjectTaskAccess(task)