expect:
        async {
            start {
                registry.runAsWorkerThread {
                    instant.worker1
                    thread.blockUntil.worker2
                }
            }
            start {
                registry.runAsWorkerThread {
                    instant.worker2
                    thread.blockUntil.worker1
                }
            }

     *
     * This method blocks until a worker lease is available.
     */
    void runAsWorkerThread(Runnable action);

    /**
     * Runs the given action as an unmanaged worker, if not already a worker. This is basically the same as {@link #runAsWorkerThread(Runnable)} but does not block waiting for a lease.
     * Instead, a temporary lease is granted to the current thread.
     *

        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()
    }

        this.workerLeaseService = workerLeaseService;
    }

    @Override
    public BuildActionRunner.Result execute(BuildAction action, BuildSessionContext context) {
        return workerLeaseService.runAsWorkerThread(() -> delegate.execute(action, context));
    }

        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();

            @Override
            void cancel() {

            }
        })
        asyncWorkTracker.registerWork(operation1, completedWorkCompletion())

        when:
        workerLeaseService.runAsWorkerThread {
            asyncWorkTracker.waitForCompletion(operation1, RELEASE_PROJECT_LOCKS)
        }

        then:
        def e = thrown(DefaultMultiCauseException)
        e.causes.size() == 1

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

                consumer.accept(((TaskNode) dependency).getTask());
            }
        }
    }

    private ExecutionResult<Void> doRun() {
        try {
            return workerLeaseService.runAsWorkerThread(workGraph::runWork);
        } catch (Throwable t) {
            return ExecutionResult.failed(t);
        }
    }

    private class BuildOpRunnable implements Runnable {

            })
        }

        then:
        thrown(NoAvailableWorkerLeaseException)
    }

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