/**
 * An execution plan that has been finalized and can no longer be mutated.
 *
 * <p>Implementations may or may not be thread-safe.</p>
 */
public interface QueryableExecutionPlan {
    QueryableExecutionPlan EMPTY = new QueryableExecutionPlan() {
        @Override
        public Set<Task> getTasks() {
            return Collections.emptySet();
        }

        @Override

        @Override
        public WorkSource<Node> asWorkSource() {
            throw new IllegalStateException();
        }

        @Override
        public QueryableExecutionPlan getContents() {
            return QueryableExecutionPlan.EMPTY;
        }

        @Override
        public String getDisplayName() {
            return "empty";
        }

        @Override
        public void close() {

import org.gradle.api.internal.GradleInternal;
import org.gradle.execution.plan.ExecutionPlan;
import org.gradle.execution.plan.QueryableExecutionPlan;

public interface EntryTaskSelector {
    void applyTasksTo(Context context, ExecutionPlan plan);

    default void postProcessExecutionPlan(Context context, QueryableExecutionPlan plan) {
    }

    interface Context {
        TaskSelection getSelection(String taskPath);

 */

package org.gradle.internal.build;

import org.gradle.api.Task;
import org.gradle.api.specs.Spec;
import org.gradle.execution.EntryTaskSelector;
import org.gradle.execution.plan.QueryableExecutionPlan;
import org.gradle.internal.concurrent.Stoppable;

import java.util.Collection;
import java.util.function.BiConsumer;
import java.util.function.Consumer;

public interface BuildWorkGraph extends Stoppable {

            // create copy now - https://github.com/gradle/gradle/issues/12527
            QueryableExecutionPlan contents = plan.getContents();
            Set<Task> requestedTasks = contents.getRequestedTasks();
            Set<Task> filteredTasks = contents.getFilteredTasks();
            QueryableExecutionPlan.ScheduledNodes scheduledWork = contents.getScheduledNodes();

        List<Node> nodes = [t]

        def scheduledNodesStub = Stub(QueryableExecutionPlan.ScheduledNodes) {
            visitNodes(_) >> { BiConsumer<List<Node>, Set<Node>> consumer ->
                consumer.accept(nodes, new HashSet<Node>(nodes))
            }
        }

        def executionPlan = Stub(ExecutionPlan) {
            getContents() >> Stub(QueryableExecutionPlan) {
                getScheduledNodes() >> scheduledNodesStub

import org.gradle.api.internal.StartParameterInternal
import org.gradle.api.internal.TaskInternal
import org.gradle.execution.plan.FinalizedExecutionPlan
import org.gradle.execution.plan.QueryableExecutionPlan
import org.gradle.internal.SystemProperties
import org.gradle.internal.logging.text.TestStyledTextOutputFactory
import org.gradle.util.Path
import spock.lang.Specification

import org.gradle.api.specs.Spec;
import org.gradle.composite.internal.TaskIdentifier;
import org.gradle.execution.EntryTaskSelector;
import org.gradle.execution.plan.ExecutionPlan;
import org.gradle.execution.plan.QueryableExecutionPlan;
import org.gradle.internal.build.BuildLifecycleController;
import org.gradle.internal.build.BuildState;
import org.gradle.internal.build.ExecutionResult;

import java.util.Collection;

import java.util.function.BiConsumer;

/**
 * An immutable snapshot of the currently scheduled nodes, together with the information about which nodes are entry points.
 */
public class ScheduledWork implements QueryableExecutionPlan.ScheduledNodes {
    private final ImmutableList<Node> scheduledNodes;
    private final ImmutableSet<Node> entryNodes;

 */
package org.gradle.composite.internal;

import org.gradle.api.Task;
import org.gradle.api.specs.Spec;
import org.gradle.execution.EntryTaskSelector;
import org.gradle.execution.plan.QueryableExecutionPlan;
import org.gradle.internal.build.BuildLifecycleController;
import org.gradle.internal.build.ExecutionResult;
import org.gradle.internal.build.ExportedTaskNode;
import org.gradle.internal.concurrent.Stoppable;