/**
 * 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

            // 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 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;

import org.gradle.execution.EntryTaskSelector;
import org.gradle.execution.TaskSelection;
import org.gradle.execution.TaskSelectionException;
import org.gradle.execution.plan.ExecutionPlan;
import org.gradle.execution.plan.QueryableExecutionPlan;
import org.gradle.internal.build.event.types.DefaultTestDescriptor;
import org.gradle.process.internal.DefaultJavaDebugOptions;
import org.gradle.tooling.internal.protocol.events.InternalJvmTestDescriptor;

            List<BiConsumer<EntryTaskSelector.Context, QueryableExecutionPlan>> finalizations = workPlan.finalizations;
            if (!finalizations.isEmpty()) {
                EntryTaskSelectorContext context = new EntryTaskSelectorContext();
                for (BiConsumer<EntryTaskSelector.Context, QueryableExecutionPlan> finalization : finalizations) {

import org.gradle.execution.EntryTaskSelector
import org.gradle.execution.TaskSelection
import org.gradle.execution.TaskSelectionResult
import org.gradle.execution.plan.ExecutionPlan
import org.gradle.execution.plan.QueryableExecutionPlan
import org.gradle.internal.build.BuildProjectRegistry
import org.gradle.internal.build.BuildState
import org.gradle.internal.build.event.types.DefaultTestDescriptor

import org.gradle.api.internal.TaskInternal;
import org.gradle.api.specs.Spec;
import org.gradle.execution.EntryTaskSelector;
import org.gradle.execution.plan.PlanExecutor;
import org.gradle.execution.plan.QueryableExecutionPlan;
import org.gradle.internal.build.BuildLifecycleController;
import org.gradle.internal.build.BuildState;
import org.gradle.internal.build.BuildStateRegistry;
import org.gradle.internal.build.ExecutionResult;

    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.
     */
    QueryableExecutionPlan getContents();

    /**
     * Calculates the execution plan for the current entry tasks. May be called multiple times.
     */
    void determineExecutionPlan();

    /**

/**
 * The mutation methods on this implementation are NOT threadsafe, and callers must synchronize access to these methods.
 */
@NonNullApi
public class DefaultExecutionPlan implements ExecutionPlan, QueryableExecutionPlan {
    private final Set<Node> entryNodes = new LinkedHashSet<>();
    private final NodeMapping nodeMapping = new NodeMapping();
    private final String displayName;
    private final TaskNodeFactory taskNodeFactory;