def task = task(build, node)
                graphBuilder.addEntryTasks([task])
            }
            builder.withWorkGraph(childBuild.state) { graphBuilder ->
                def task = task(childBuild, childNode)
                graphBuilder.addEntryTasks([task])
            }
        }

        then:
        result.failures.empty
        childNode.executed

        Task a = task("a")
        Task b = task("b")
        Task c = task("c")
        Task d = task("d")

        when:
        executionPlan.addEntryTasks([c, b])
        executionPlan.addEntryTasks([d, a])
        execute()

        then:
        executedTasks == [b, c, a, d]
        failures.empty
    }

    def "executes shared dependencies of batches once only"() {

        then:
        1 * parser.parseTasks(request1) >> [selection1]
        1 * parser.parseTasks(request2) >> [selection2]
        1 * executionPlan.addEntryTasks(tasks1)
        1 * executionPlan.addEntryTasks(tasks2)
    }

    def "invokes given selector"() {
        given:
        def startParameters = Mock(StartParameterInternal)

        when:

    }

    @Override
    public void addEntryTask(Task task) {
        addEntryTasks(Collections.singletonList(task));
    }

    @Override
    public void addEntryTasks(Collection<? extends Task> tasks) {
        addEntryTasks(tasks, order++);
    }

    private void addEntryTasks(Collection<? extends Task> tasks, int ordinal) {

            for (TaskSelection taskSelection : taskSelections) {
                LOGGER.info("Selected primary task '{}' from project {}", taskSelection.getTaskName(), taskSelection.getProjectPath());
                plan.addEntryTasks(taskSelection.getTasks());
            }
        }
    }

    @NonNullApi
    private class EntryTaskSelectorContext implements EntryTaskSelector.Context {
        final GradleInternal gradle;

    /**
     * Adds entry tasks to the execution plan. No ordering can be assumed between the elements of the target collection. If called multiple times then execution plan follows the method invocation order.
     */
    void addEntryTasks(Collection<? extends Task> tasks);

    /**
     * Returns a snapshot of the current contents of this plan. Note that this plan is mutable, so the contents may later change.
     */

                resolver.prepareClassPath(classpathConfiguration, resolutionContext);
                classpathConfiguration.getDependencies().add(rootProject.getDependencies().create(rootProject));
                plan.addEntryTasks(getDependenciesForInternalUse(classpathConfiguration));
            });
        }

        public ClassPath getRuntimeClasspath() {

        when:
        buildConfigurationAction.applyTasksTo(context, executionPlan)
        then:
        0 * buildProjectRegistry.allProjects
        _ * executionPlan.addEntryTasks({ args -> assert args.size() == 0 })
        _ * executionPlan.addEntryTask({ args -> assert args.size() == 0 })
    }

    def "sets test filter with information from #requestType"() {
        setup:

                createPlan();
                controller.prepareToScheduleTasks();
                controller.populateWorkGraph(plan, workGraph -> workGraph.addEntryTasks(tasks));
            });
            return true;
        }

        @Override
        public void populateWorkGraph(Consumer<? super BuildLifecycleController.WorkGraphBuilder> action) {

         */
        void addRequestedTasks(@Nullable EntryTaskSelector selector);

        /**
         * Adds the given tasks and their dependencies to the work graph for this build.
         */
        void addEntryTasks(List<? extends Task> tasks);

        /**