Laura Kassovic <******@****.***> 1701107622 -0800

            workerThread {
                asyncWorkTracker.waitForCompletion(operation1, RELEASE_PROJECT_LOCKS)
            }
            thread.blockUntil.waitStarted
            workerThread {
                try {
                    asyncWorkTracker.registerWork(operation1, new AsyncWorkCompletion() {
                        @Override
                        void waitForCompletion() {
                        }

     * @param completion - The completion of the asynchronous work
     * @throws IllegalStateException when new work is submitted for an operation while another thread is waiting in {@link #waitForCompletion(BuildOperationRef, ProjectLockRetention)} for the same operation.
     */
    void registerWork(BuildOperationRef operation, AsyncWorkCompletion completion);

    /**

        given:
        setupQueue(threads)
        def success = Mock(TestBuildOperation)

        when:
        runs.times { operationQueue.add(success) }

        and:
        operationQueue.waitForCompletion()

        then:
        runs * success.run(_)

        where:
        runs | threads
        0    | 1
        0    | 4
        0    | 10
        1    | 1
        1    | 4

        then:
        1 * action1.execute(task) >> {
            assert state.executing
        }
        then:
        1 * action1.clearInputChanges()
        then:
        1 * asyncWorkTracker.waitForCompletion(_, RELEASE_AND_REACQUIRE_PROJECT_LOCKS)
        then:
        1 * standardOutputCapture.stop()
        then:
        1 * standardOutputCapture.start()
        then:

 * <p>
 * The queue is active in that operations are potentially executed as soon as they are added.
 * The queue is single use in that no further work can be added once {@link #waitForCompletion()} has completed.
 * <p>
 * A queue instance is threadsafe. Build operations can submit further operations to the queue but must not block waiting for them to complete.
 *
 * @param <T> type of build operations to hold

            }
            items.put(operation, workCompletion);
        } finally {
            lock.unlock();
        }
    }

    @Override
    public void waitForCompletion(BuildOperationRef operation, ProjectLockRetention lockRetention) {
        final List<AsyncWorkCompletion> workItems;
        lock.lock();
        try {
            workItems = ImmutableList.copyOf(items.get(operation));

        when:
        workerExecutor.await()

        then:
        1 * asyncWorkerTracker.waitForCompletion(_, RETAIN_PROJECT_LOCKS)
    }

    def "all errors are thrown when waiting on multiple results"() {
        when:
        workerExecutor.await()

        then:
        1 * asyncWorkerTracker.waitForCompletion(_, RETAIN_PROJECT_LOCKS) >> {

        try {
            if (asyncWorkTracker.hasUncompletedWork(currentOperation)) {
                executionQueue.expand();
            }
            asyncWorkTracker.waitForCompletion(currentOperation, RETAIN_PROJECT_LOCKS);
        } catch (DefaultMultiCauseException e) {
            throw workerExecutionException(e.getCauses());
        }
    }

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

    @Override
    void assertSampleSpecificOutcome(String dsl) {