// There are several well-known algorithms for rotating part of an array (or, equivalently,
    // exchanging two blocks of memory). This classic text by Gries and Mills mentions several:
    // https://ecommons.cornell.edu/bitstream/handle/1813/6292/81-452.pdf.
    // (1) "Reversal", the one we have here.

  }

  private class ThreadedService extends AbstractService {
    final CountDownLatch hasConfirmedIsRunning = new CountDownLatch(1);

    /*
     * The main test thread tries to stop() the service shortly after
     * confirming that it is running. Meanwhile, the service itself is trying
     * to confirm that it is running. If the main thread's stop() call happens

  }

  /**
   * Returns the Method that can be used to return the size of a stack, or null if that method
   * cannot be found (it is only to be found in fairly recent JDKs). Tries to test method {@link
   * sun.misc.JavaLangAccess#getStackTraceDepth(Throwable) getStackTraceDepth} prior to return it
   * (might fail some JDKs).
   *

  }

  /**
   * Returns the Method that can be used to return the size of a stack, or null if that method
   * cannot be found (it is only to be found in fairly recent JDKs). Tries to test method {@link
   * sun.misc.JavaLangAccess#getStackTraceDepth(Throwable) getStackTraceDepth} prior to return it
   * (might fail some JDKs).
   *

    awaitDone(
        new FinalizationPredicate() {
          @Override
          public boolean isDone() {
            return ref.get() == null;
          }
        });
  }

  /**
   * Tries to perform a "full" garbage collection cycle (including processing of weak references and
   * invocation of finalize methods) and waits for it to complete. Ensures that at least one weak

  }

  private class ThreadedService extends AbstractService {
    final CountDownLatch hasConfirmedIsRunning = new CountDownLatch(1);

    /*
     * The main test thread tries to stop() the service shortly after
     * confirming that it is running. Meanwhile, the service itself is trying
     * to confirm that it is running. If the main thread's stop() call happens

  }

  /**
   * This test attempts to cause a future to wait for longer than it was requested to from a timed
   * get() call. As measurements of time are prone to flakiness, it tries to assert based on ranges
   * derived from observing how much time actually passed for various operations.
   */
  @SuppressWarnings({"DeprecatedThreadMethods", "ThreadPriorityCheck"})
  @AndroidIncompatible // Thread.suspend

 *
 * <p>For {@code ImmutableMultiset} in particular, I ran into a problem with the {@code
 * GwtSerializationDependencies} approach: When autogenerating a serializer for the new class, GWT
 * tries to refer to our dummy serializer for the superclass,
 * ImmutableMultiset_CustomFieldSerializer. But that type has no methods (since it's never actually

import com.google.caliper.BeforeExperiment;
import com.google.caliper.Benchmark;
import com.google.caliper.Param;
import com.google.caliper.api.SkipThisScenarioException;
import java.util.Random;

/** A benchmark that tries invoking {@code Set.contains} on many different sets. */
public class MultipleSetContainsBenchmark {

  @Param({"0.0", "0.1", "0.7", "1.0"})
  double emptySetProportion;

  @Param({"0.0", "0.1", "0.7", "1.0"})

import java.io.Serializable;
import java.util.Arrays;
import java.util.Comparator;
import javax.annotation.CheckForNull;
import org.checkerframework.checker.nullness.qual.Nullable;

/** An ordering that tries several comparators in order. */
@GwtCompatible(serializable = true)
@ElementTypesAreNonnullByDefault
final class CompoundOrdering<T extends @Nullable Object> extends Ordering<T>
    implements Serializable {