new Object() {
          @Override
          protected void finalize() {
            latch.countDown();
          }
        };
    x = null; // Hint to the JIT that x is unreachable
    GcFinalization.await(latch);
    assertEquals(0, latch.getCount());
  }

  public void testAwaitDone_Future() {
    final SettableFuture<@Nullable Void> future = SettableFuture.create();
    Object x =
        new Object() {

    }

    @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 {

  //      */
  //     public void await(AtomicBoolean flag) {
  //         await(flag, LONG_DELAY_MS);
  //     }

  //     /**
  //      * Spin-waits up to the specified timeout until flag becomes true.
  //      */
  //     public void await(AtomicBoolean flag, long timeoutMillis) {
  //         long startTime = System.nanoTime();
  //         while (!flag.get()) {

        val problem = Any()
        val results = Collections.synchronizedList(mutableListOf<Boolean>())

        fun doTest() {
            reporting.enterDynamicCall(this)
            latch.countDown()
            latch.await()
            results += reporting.unreportedProblemInCurrentCall(problem)
        }

        (1..3).map { thread { doTest() } }.forEach(Thread::join)
        assertEquals(listOf(true, true, true), results)
    }

                    Thread.sleep(JAR_GENERATION_TIME_MS)
                    touch(file)
                }
            })
        }

        concurrent.start {
            startSecondInvocation.await()
            jarFile2 = defaultGeneratedGradleJarCache.get(CACHE_IDENTIFIER, new Action<File>() {
                @Override
                void execute(File file) {

            super.process(consumer);
            latch.countDown();
        }

        @Override
        public void waitForProcessed() throws InterruptedException {
            latch.await();
        }
    }

# flood reviews with unnecessary requests to demonstrate Istio rate limiting, asynchoronously


async def floodReviewsAsynchronously(product_id, headers):
    # the response is disregarded
    await asyncio.gather(*(getProductReviewsIgnoreResponse(product_id, headers) for _ in range(flood_factor)))

# flood reviews with unnecessary requests to demonstrate Istio rate limiting


def floodReviews(product_id, headers):

			// This is a blocking call for graceful termination.
			a.envoyAgent.Run(ctx)
		}()
	} else if a.WaitForSigterm() {
		// wait for SIGTERM and perform graceful shutdown
		a.wg.Add(1)
		go func() {
			defer a.wg.Done()
			<-ctx.Done()
		}()
	}
	return a.wg.Wait, nil
}

func (a *Agent) initSdsServer() error {
	var err error

    assertSame(exception, e.getCause());
  }

  private static void awaitUnchecked(final CyclicBarrier barrier) {
    try {
      barrier.await();
    } catch (Exception e) {
      throw new RuntimeException(e);
    }
  }

  private void checkStackTrace(ExecutionException e) {
    // Our call site for get() should be in the trace.

    assertSame(exception, e.getCause());
  }

  private static void awaitUnchecked(final CyclicBarrier barrier) {
    try {
      barrier.await();
    } catch (Exception e) {
      throw new RuntimeException(e);
    }
  }

  private void checkStackTrace(ExecutionException e) {
    // Our call site for get() should be in the trace.