*   <li>clearing weak references to unreachable referents
   *   <li>enqueuing weak references to unreachable referents in their reference queue
   * </ul>
   */
  @DoNotMock("Implement with a lambda")
  public interface FinalizationPredicate {
    boolean isDone();
  }

  /**
   * Waits until the given weak reference is cleared, invoking the garbage collector as necessary to

    }
  }

  /**
   * Cleans up the given reference and any other references already in the queue. Catches and logs
   * all throwables.
   *
   * @return true if the caller should continue to wait for more references to be added to the
   *     queue, false if the associated FinalizableReferenceQueue is no longer referenced.
   */
  private boolean cleanUp(Reference<?> firstReference) {

   *   <li>clearing weak references to unreachable referents
   *   <li>enqueuing weak references to unreachable referents in their reference queue
   * </ul>
   */
  @DoNotMock("Implement with a lambda")
  public interface FinalizationPredicate {
    boolean isDone();
  }

  /**
   * Waits until the given weak reference is cleared, invoking the garbage collector as necessary to

    }
  }

  /**
   * Cleans up the given reference and any other references already in the queue. Catches and logs
   * all throwables.
   *
   * @return true if the caller should continue to wait for more references to be added to the
   *     queue, false if the associated FinalizableReferenceQueue is no longer referenced.
   */
  private boolean cleanUp(Reference<?> firstReference) {

    if (threadStarted) {
      return;
    }

    Reference<?> reference;
    while ((reference = queue.poll()) != null) {
      /*
       * This is for the benefit of phantom references. Weak and soft references will have already
       * been cleared by this point.
       */
      reference.clear();
      try {
        ((FinalizableReference) reference).finalizeReferent();
      } catch (Throwable t) {

    if (threadStarted) {
      return;
    }

    Reference<?> reference;
    while ((reference = queue.poll()) != null) {
      /*
       * This is for the benefit of phantom references. Weak and soft references will have already
       * been cleared by this point.
       */
      reference.clear();
      try {
        ((FinalizableReference) reference).finalizeReferent();
      } catch (Throwable t) {

            return 0;
          }
        };

    assertEquals(0, (int) iter.next());

    assertThrows(UnsupportedOperationException.class, iter::remove);
  }


  @GwtIncompatible // weak references
  @J2ktIncompatible
  public void testFreesNextReference() {
    Iterator<Object> itr =
        new AbstractIterator<Object>() {
          @Override
          public Object computeNext() {

    assertThat(sepStopwatchA.get()).isNotNull();
    // Clear all references to the Stopwatch and wait for it to be gc'd.
    sepStopwatchA.set(null);
    GcFinalization.awaitClear(sepStopwatchRef.get());
    // Return a weak reference to the parallel ClassLoader. This is the reference that should
    // eventually become clear if there are no other references to the ClassLoader.
    return new WeakReference<ClassLoader>(sepLoader);
  }

    assertThrows(NoSuchElementException.class, iter::next);
    assertThrows(NoSuchElementException.class, iter::peek);
  }


  @J2ktIncompatible // weak references, details of GC
  @GwtIncompatible // weak references
  public void testFreesNextReference() {
    Iterator<Object> itr =
        new AbstractIterator<Object>() {
          @Override
          public Object computeNext() {

    assertThrows(NoSuchElementException.class, iter::next);
    assertThrows(NoSuchElementException.class, iter::peek);
  }


  @J2ktIncompatible // weak references, details of GC
  @GwtIncompatible // weak references
  public void testFreesNextReference() {
    Iterator<Object> itr =
        new AbstractIterator<Object>() {
          @Override
          public Object computeNext() {