* limitations under the License.
 */

package org.gradle.kotlin.dsl.concurrent

import org.awaitility.Duration.ONE_SECOND
import org.awaitility.kotlin.atMost
import org.awaitility.kotlin.await
import org.awaitility.kotlin.untilNotNull

import org.gradle.kotlin.dsl.support.useToRun

import org.hamcrest.CoreMatchers.equalTo
import org.hamcrest.CoreMatchers.instanceOf

                              // WAIT #1
                              barrier.await(1, TimeUnit.SECONDS);

                              // WAIT #2
                              barrier.await(1, TimeUnit.SECONDS);
                              assertTrue(executor.isShutdown());
                              assertFalse(executor.isTerminated());

                              // WAIT #3

    }

    @Override
    public void await() throws InterruptedException {
      lock.lock();
      try {
        condition.await();
      } finally {
        lock.unlock();
      }
    }

    @Override
    public boolean await(long time, TimeUnit unit) throws InterruptedException {
      lock.lock();
      try {
        return condition.await(time, unit);
      } finally {

            collectOutputs(builder)
            builder.setStreamedValueListener(listener)
            builder.run(handler)

            modelReceived.await()
            request.waitForAllPendingCalls()
            request.releaseAll()
            finished.await()
        }

        then:
        models.size() == 2
        models[0] instanceof GradleProject
        models[1] instanceof CustomModel
    }

 * Object x = new MyClass() {
 *   ...
 *   protected void finalize() { latch.countDown(); ... }
 * };
 * x = null;  // Hint to the JIT that x is stack-unreachable
 * GcFinalization.await(latch);
 * }</pre>
 *
 * <p>Here's an example that uses a user-defined finalization predicate:
 *
 * <pre>{@code
 * final WeakHashMap<Object, Object> map = new WeakHashMap<>();
 * map.put(new Object(), Boolean.TRUE);

    }

    def "can wait on results to complete"() {
        when:
        workerExecutor.await()

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

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

        then:

                operationQueue.waitForCompletion()
            }
        })
        waitForCompletionThread.start()

        and:
        // wait for operations to begin running
        startedLatch.await(30, TimeUnit.SECONDS)

        and:
        operationQueue.cancel()

        and:
        // release the running operations to complete
        releaseLatch.countDown()

        elif is_gen_callable(call) or is_async_gen_callable(call):
            solved = await solve_generator(
                call=call, stack=async_exit_stack, sub_values=sub_values
            )
        elif is_coroutine_callable(call):
            solved = await call(**sub_values)
        else:
            solved = await run_in_threadpool(call, **sub_values)
        if sub_dependant.name is not None:

                    condition.signalAll();
                    throw failure;
                }
                try {
                    condition.await(waitMs, TimeUnit.MILLISECONDS);
                } catch (InterruptedException e) {
                    throw UncheckedException.throwAsUncheckedException(e);
                }
            }
            if (failure != null) {

            });
        }

        // start all threads at once
        try {
            startLatch.await();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        // wait for all thread to end
        try {
            endLatch.await();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }