return 0
    }

    @Override
    WorkerLease getCurrentWorkerLease() {
        return workerLease()
    }

    @Override
    <T> T runAsWorkerThread(Factory<T> action) {
        return action.create()
    }

    @Override
    void runAsWorkerThread(Runnable action) {
        action.run()
    }

    @Override
    void runAsUnmanagedWorkerThread(Runnable action) {
        action.run()
    }

        println "expecting ${expectedWorkerCount} concurrent work processors to be started..."

        when:
        def waitForCompletionThread = new Thread({
            workerRegistry.runAsWorkerThread {
                runs.times { operationQueue.add(new SynchronizedBuildOperation(operationAction, startedLatch, releaseLatch)) }
                operationQueue.waitForCompletion()
            }
        })

        }
        return withLocks(Collections.singletonList(newWorkerLease()), action);
    }

    @Override
    public void runAsWorkerThread(Runnable action) {
        runAsWorkerThread(Factories.<Void>toFactory(action));
    }

    @Override
    public void runAsUnmanagedWorkerThread(Runnable action) {
        Collection<? extends ResourceLock> locks = workerLeaseLockRegistry.getResourceLocksByCurrentThread();

        /**
         * Run executions until there are none ready to be executed.
         */
        private void runBatch(final ConditionalExecution<?> firstOperation) {
            workerLeaseService.runAsWorkerThread(new Runnable() {
                @Override
                public void run() {
                    ConditionalExecution<?> operation = firstOperation;
                    while (operation != null) {

            })
        }

        then:
        thrown(NoAvailableWorkerLeaseException)
    }

    def workerThread(Closure cl) {
        start {
            workerRegistry.runAsWorkerThread(cl)
        }
    }

        }

        registry.registerProjects(build, descriptors)

        return build
    }

    void workerThread(Closure closure) {
        start {
            workerLeaseService.runAsWorkerThread(closure)
        }
    }

        return new StateTransitionController<TestState>(Describables.of("<state>"), initialState, workerLeaseService.newResource())
    }

    def <T> T asWorker(Factory<T> action) {
        return workerLeaseService.runAsWorkerThread(action)
    }

    def "runs action for transition when in from state"() {
        def action = Mock(Runnable)
        def controller = controller(TestState.A)

        when:
        asWorker {

    }

    ExecutionResult<Void> scheduleAndRun(TreeServices services, Action<BuildTreeWorkGraph.Builder> action) {
        def result = null
        services.workerLeaseService.runAsWorkerThread {
            services.buildTaskGraph.withNewWorkGraph { graph ->
                graph.scheduleWork { builder ->
                    action(builder)
                }
                result = graph.runWork()