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:

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,

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

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

        t3 == failure
    }

    void testCanExecuteTasksWhenNothingHasBeenScheduled() {
        when:
        def controller = controller()
        def workGraph = controller.newWorkGraph()
        def result = controller.executeTasks(workGraph)

        then:
        result.failures.empty

        when:
        def finishResult = controller.finishBuild(null)

        then:

            readRequiredBuildServicesOf(gradle)

            val workGraph = readWorkGraph(gradle)
            readFlowScopeOf(gradle)
            readBuildOutputCleanupRegistrations(gradle)
            return BuildWithWork(build.state.identityPath, build, gradle.rootProject.name, projects, workGraph)
        } else {
            return BuildWithNoProjects(build.state.identityPath)
        }
    }

        return loadFromCache(StateType.Work) { stateFile ->
            val (buildInvocationId, workGraph) = cacheIO.readRootBuildStateFrom(stateFile, loadAfterStore, graph, graphBuilder)
            LoadResult(stateFile.stateFile.file, buildInvocationId) to workGraph
        }
    }

    private

.src/einstein.txt
[source,text]
----
include::{snippetsPath}/workerApi/md5CustomTask/groovy/src/einstein.txt[]
----

.src/feynman.txt
[source,text]
----
include::{snippetsPath}/workerApi/md5CustomTask/groovy/src/feynman.txt[]
----

.src/hawking.txt
[source,text]
----
include::{snippetsPath}/workerApi/md5CustomTask/groovy/src/hawking.txt[]
----

import org.gradle.util.internal.TextUtil

@IntegrationTestTimeout(60)
class WaitForCompletionWorkerExecutorSampleIntegrationTest extends AbstractWorkerExecutorSampleIntegrationTest {
    String getSampleName() {
        "workerApi/waitForCompletion"
    }

    @Override
    void assertSampleSpecificOutcome(String dsl) {