@Override
          protected void finalize() {
            future.set(null);
          }
        };
    unused = null; // Hint to the JIT that unused is unreachable
    GcFinalization.awaitDone(future);
    assertTrue(future.isDone());
    assertFalse(future.isCancelled());
  }

  public void testAwaitDone_future_cancel() {
    final SettableFuture<@Nullable Void> future = SettableFuture.create();

          @Override
          protected void finalize() {
            future.set(null);
          }
        };
    unused = null; // Hint to the JIT that unused is unreachable
    GcFinalization.awaitDone(future);
    assertTrue(future.isDone());
    assertFalse(future.isCancelled());
  }

  public void testAwaitDone_future_cancel() {
    final SettableFuture<@Nullable Void> future = SettableFuture.create();

   *
   * <pre>{@code
   * awaitDone(new FinalizationPredicate() {
   *   public boolean isDone() {
   *     return ref.get() == null;
   *   }
   * });
   * }</pre>
   *
   * @throws RuntimeException if timed out or interrupted while waiting
   */
  public static void awaitClear(WeakReference<?> ref) {
    awaitDone(
        new FinalizationPredicate() {
          @Override

   *
   * <pre>{@code
   * awaitDone(new FinalizationPredicate() {
   *   public boolean isDone() {
   *     return ref.get() == null;
   *   }
   * });
   * }</pre>
   *
   * @throws RuntimeException if timed out or interrupted while waiting
   */
  public static void awaitClear(WeakReference<?> ref) {
    awaitDone(
        new FinalizationPredicate() {
          @Override

      env:
        TOKEN: ${{ secrets.GITHUB_TOKEN }}
        CONFIG: >
          {
            "approved-1":
              {
                "number": 1,
                "await_label": "awaiting-review"
              }

from pydantic_settings import BaseSettings


class LabelSettings(BaseModel):
    await_label: str | None = None
    number: int


default_config = {"approved-2": LabelSettings(await_label="awaiting-review", number=2)}


class Settings(BaseSettings):
    github_repository: str
    token: SecretStr
    debug: bool | None = False
    config: dict[str, LabelSettings] | Literal[""] = default_config

    frq = null;
  }


  public void testFinalizeReferentCalled() {
    final MockReference reference = new MockReference(frq = new FinalizableReferenceQueue());

    GcFinalization.awaitDone(
        new GcFinalization.FinalizationPredicate() {
          @Override
          public boolean isDone() {
            return reference.finalizeReferentCalled;
          }
        });
  }

    // launched by this test is either:
    //
    // (a) Blocked attempting to enter the monitor.
    // (b) Waiting for the single guard to become satisfied.
    // (c) Occupying the monitor and awaiting the tearDownLatch.
    //
    // Except for (c), every thread should occupy the monitor very briefly, and every thread leaves
    // the monitor with the guard satisfied. Therefore as soon as tearDownLatch is triggered, we

    change.
-   You make the change and submit it for the review again.
-   This cycle repeats itself until the PR gets approved.
-   Note: As a friendly reminder, we may reach out to you if the PR is awaiting
    your response for more than 2 weeks.

**4. Approved**

-   Once the PR is approved, it gets `kokoro:force-run` label applied and it
    initiates CI/CD tests.
-   We can't move forward if these tests fail.

## `async` and `await`

Modern versions of Python have a very intuitive way to define asynchronous code. This makes it look just like normal "sequential" code and do the "awaiting" for you at the right moments.

When there is an operation that will require waiting before giving the results and has support for these new Python features, you can code it like:

```Python