assertInState(State.DiscoveringTasks);
        workGraph.populateWorkGraph(action);
    }

    @Override
    public void addFilter(Spec<Task> filter) {
        assertInState(State.DiscoveringTasks);
        workGraph.addFilter(filter);
    }

    @Override

        DefaultBuildTreeWorkGraph previous = current.get();
        DefaultBuildTreeWorkGraph workGraph = new DefaultBuildTreeWorkGraph();
        current.set(workGraph);
        try {
            try {
                return action.apply(workGraph);
            } finally {
                workGraph.close();
            }
        } finally {
            current.set(previous);
        }
    }

            f.runWork().rethrow()
        }

        then:
        1 * workGraphController.newWorkGraph() >> workGraph
        1 * preparer.prepareToScheduleTasks(_)
        1 * workGraph.populateWorkGraph(_)
        1 * workGraph.finalizeGraph()
        1 * workGraph.runWork() >> ExecutionResult.succeeded()
    }

    def "cannot schedule tasks when graph has not been created"() {
        when:

    def buildStateRegistry = Mock(BuildStateRegistry)

    BuildState build(BuildIdentifier id, BuildWorkGraphController workGraph = null) {
        def build = Mock(IncludedBuildState)
        _ * build.buildIdentifier >> id
        _ * build.workGraph >> (workGraph ?: Stub(BuildWorkGraphController))
        _ * buildStateRegistry.getBuild(id) >> build
        return build
    }

class ConfigurationCacheAwareBuildTreeWorkController(
    private val workPreparer: BuildTreeWorkPreparer,
    private val workExecutor: BuildTreeWorkExecutor,
    private val workGraph: BuildTreeWorkGraphController,
    private val cache: BuildTreeConfigurationCache,
    private val buildRegistry: BuildStateRegistry,
    private val startParameter: ConfigurationCacheStartParameter,

                    }
                });
            }
            currentOwner = Thread.currentThread();
            DefaultBuildWorkGraph workGraph = new DefaultBuildWorkGraph();
            pendingGraphs.add(workGraph);
            return workGraph;
        }
    }

    private DefaultExportedTaskNode doLocate(TaskIdentifier taskIdentifier) {

        RootBuildState targetBuild = buildRegistry.getRootBuild();
        Set<String> excludedTaskNames = targetBuild.getMutableModel().getStartParameter().getExcludedTaskNames();
        for (String taskName : excludedTaskNames) {
            BuildTaskSelector.Filter filter = taskSelector.resolveExcludedTaskName(targetBuild, taskName);
            workGraph.addFilter(filter.getBuild(), filter.getFilter());

    private val cache: BuildTreeConfigurationCache
) : BuildTreeWorkGraphPreparer {
    override fun prepareToScheduleTasks(workGraph: BuildTreeWorkGraph.Builder) {
        if (!cache.isLoaded) {
            delegate.prepareToScheduleTasks(workGraph)
        } // else, not required
    }

/**
 * Performs any initial setup that needs to happen to a build tree work graph prior to scheduling the requested tasks.
 */
public interface BuildTreeWorkGraphPreparer {
    void prepareToScheduleTasks(BuildTreeWorkGraph.Builder workGraph);

 */
internal
class BuildWithWork(
    identityPath: Path,
    val build: ConfigurationCacheBuild,
    rootProjectName: String,
    projects: List<CachedProjectState>,
    val workGraph: ScheduledWork
) : BuildWithProjects(identityPath, rootProjectName, projects)


/**
 * A build in the tree with no work scheduled.
 */
internal
class BuildWithNoWork(
    identityPath: Path,