logger.severe("InterruptenatorTask did not exit; future tests may be affected");
              /*
               * This won't do any good under JUnit 3, but I'll leave it around in
               * case we ever switch to JUnit 4:
               */
              fail();
            }
          }
        });
  }

through the air!  Do you think you could manage it?)  `And what
an ignorant little girl she'll think me for asking!  No, it'll
never do to ask:  perhaps I shall see it written up somewhere.'

  Down, down, down.  There was nothing else to do, so Alice soon
began talking again.  `Dinah'll miss me very much to-night, I
should think!'  (Dinah was the cat.)  `I hope they'll remember
her saucer of milk at tea-time.  Dinah my dear!  I wish you were

        Method unused = clazz.getDeclaredMethod("writeReplace");
        continue; // It overrides writeReplace, so it's safe.
      } catch (NoSuchMethodException e) {
        // This is a class whose supertypes we want to examine. We'll do that below.
      }
      Optional<Class<?>> supersWithPackagePrivateWriteReplace =
          FluentIterable.from(TypeToken.of(clazz).getTypes())
              .transform(TypeToken::getRawType)

        Method unused = clazz.getDeclaredMethod("writeReplace");
        continue; // It overrides writeReplace, so it's safe.
      } catch (NoSuchMethodException e) {
        // This is a class whose supertypes we want to examine. We'll do that below.
      }
      Optional<Class<?>> supersWithPackagePrivateWriteReplace =
          FluentIterable.from(TypeToken.of(clazz).getTypes())
              .transform(TypeToken::getRawType)

   * a good policy, especially because, in order for the test to pass, the
   * parameter must be misleadingly annotated as @Nullable. I suspect that
   * we'll want to remove @Nullable, add an eager checkNotNull, and loosen up
   * testRemove_nullAllowed.
   */
  @CanIgnoreReturnValue
  @Override
  public int remove(@CheckForNull Object element, int occurrences) {

        validateMethod(method);
        addTests(suite, method);
      }
    }

    assertEquals(548, suite.testCount());

    return suite;
  }

  /** A typical timeout value we'll use in the tests. */
  private static final long SMALL_TIMEOUT_MILLIS = 10;

  /** How long to wait when determining that a thread is blocked if we expect it to be blocked. */

  }

  @AfterExperiment
  void tearDown() {
    double req = requests.get();
    double hit = req - misses.get();

    // Currently, this is going into /dev/null, but I'll fix that
    System.out.println("hit rate: " + hit / req);
  }

  // for proper distributions later:
  // import JSci.maths.statistics.ProbabilityDistribution;
  // int key = (int) dist.inverse(random.nextDouble());

     */
    @SuppressWarnings("removal") // b/318391980
    private static Unsafe getUnsafe() {
      try {
        return Unsafe.getUnsafe();
      } catch (SecurityException tryReflectionInstead) {
        // We'll try reflection instead.
      }
      try {
        return AccessController.doPrivileged(
            (PrivilegedExceptionAction<Unsafe>)
                () -> {
                  Class<Unsafe> k = Unsafe.class;

    // So we can ignore the bottom 11, except for rounding. We can unsigned-shift right 1, aka
    // unsigned-divide by 2, and convert that. Then we'll get exactly half of the desired double
    // value. But in the specific case where the bottom two bits of the original number are 01, we
    // want to replace that with 1 in the shifted value for correct rounding.

    return indexOf(target) >= 0;
  }

  @GwtIncompatible // super.subListUnchecked does not exist; inherited subList is valid if slow
  /*
   * TODO(cpovirk): if we start to override indexOf/lastIndexOf under GWT, we'll want some way to
   * override subList to return an ImmutableSortedAsList for better performance. Right now, I'm not
   * sure there's any performance hit from our failure to override subListUnchecked under GWT
   */
  @Override