def "does no work when nothing scheduled"() {
        when:
        graph.withNewWorkGraph { g ->
            def f = g.scheduleWork { b ->
            }
            f.runWork().rethrow()
        }

        then:
        1 * preparer.prepareToScheduleTasks(_)
        0 * _
    }

     *
     * <p>This can be called only once for a given graph.</p>
     */
    FinalizedGraph scheduleWork(Consumer<? super Builder> action);

    interface FinalizedGraph {
        /**
         * Runs any scheduled work, blocking until complete. Does nothing when {@link #scheduleWork(Consumer)} has not been called to schedule the work.
         *
         * <p>This can be called only once for a given graph.</p>

    @Override
    public BuildTreeWorkGraph.FinalizedGraph scheduleRequestedTasks(BuildTreeWorkGraph graph, @Nullable EntryTaskSelector selector) {
        targetBuildController.prepareToScheduleTasks();
        return graph.scheduleWork(graphBuilder -> {
            if (selector != null) {
                graphBuilder.addFinalization(targetBuild, selector::postProcessExecutionPlan);
            }

        public boolean isComplete() {
            return complete;
        }
    }

    /**
     * Queues the task for execution, but does not schedule it. Use {@link org.gradle.internal.buildtree.BuildTreeWorkGraph#scheduleWork(Consumer)} to schedule queued tasks.
     */
    void queueForExecution();

    /**

    }

    private <T> T doBuild(List<TaskIdentifier.TaskBasedTaskIdentifier> tasks, Supplier<T> continuationUnderLock) {
        buildTreeWorkGraphController.withNewWorkGraph(graph -> {
            graph
                .scheduleWork(builder -> builder.scheduleTasks(tasks))
                .runWork()
                .rethrow();
            return null;
        });
        return continuationUnderLock.get();
    }

            assertIsOwner();
            assertCanQueueTask();
            controllers.getBuildController(build).queueForExecution(taskNode);
        }

        @Override
        public FinalizedGraph scheduleWork(Consumer<? super Builder> action) {
            assertIsOwner();
            expectInState(State.NotPrepared);
            state = State.Preparing;
            buildOperationRunner.run(new RunnableBuildOperation() {

        def result = null
        services.workerLeaseService.runAsWorkerThread {
            services.buildTaskGraph.withNewWorkGraph { graph ->
                graph.scheduleWork { builder ->
                    action(builder)
                }
                result = graph.runWork()
            }
            // Ensure that everything can be cleanly stopped
            services.stop()

        val state = build.state
        if (state.isProjectsCreated) {
            writeBoolean(true)
            val scheduledWork = build.scheduledWork
            withDebugFrame({ "Gradle" }) {
                writeGradleState(gradle)
                val projects = collectProjects(state.projects, scheduledWork.scheduledNodes, gradle.serviceOf())
                writeProjects(gradle, projects)

 */
public class ScheduledWork implements QueryableExecutionPlan.ScheduledNodes {
    private final ImmutableList<Node> scheduledNodes;
    private final ImmutableSet<Node> entryNodes;

    public ScheduledWork(List<? extends Node> scheduledNodes, Collection<? extends Node> entryNodes) {

import org.gradle.api.internal.GradleInternal
import org.gradle.execution.plan.ScheduledWork
import org.gradle.internal.build.BuildState


interface VintageGradleBuild {
    val isRootBuild: Boolean
    val state: BuildState
    val gradle: GradleInternal
    val hasScheduledWork: Boolean
    val scheduledWork: ScheduledWork