private static final Integer I1 = -1;
  private static final Integer I2 = 3;
  private static final String S0 = "3";
  private static final String S1 = "Ninety five";
  private static final String S2 = "44 one million";
  private static final String S3 = "Lowly laundry lefties";
  private static final String S4 = "89273487U#*&#";
  private static final Double D0 = 9.234d;
  private static final Double D1 = -1.2e55;

  @Benchmark

  private static final Integer I1 = -1;
  private static final Integer I2 = 3;
  private static final String S0 = "3";
  private static final String S1 = "Ninety five";
  private static final String S2 = "44 one million";
  private static final String S3 = "Lowly laundry lefties";
  private static final String S4 = "89273487U#*&#";
  private static final Double D0 = 9.234d;
  private static final Double D1 = -1.2e55;

  @Benchmark

    MIN(Long.MIN_VALUE, "-oo"),
    MINUS_SMALL(-SMALL_TIMEOUT_MILLIS, "-" + SMALL_TIMEOUT_MILLIS + "ms"),
    ZERO(0L, "0ms"),
    SMALL(SMALL_TIMEOUT_MILLIS, SMALL_TIMEOUT_MILLIS + "ms"),
    LARGE(UNEXPECTED_HANG_DELAY_MILLIS * 2, (2 * UNEXPECTED_HANG_DELAY_MILLIS) + "ms"),
    MAX(Long.MAX_VALUE, "+oo");

    final long millis;
    final String label;

    Timeout(long millis, String label) {
      this.millis = millis;

  }

  private static class SleepingRunnable implements Runnable {
    final int millis;
    volatile boolean completed;

    public SleepingRunnable(int millis) {
      this.millis = millis;
    }

    @Override
    public void run() {
      try {
        Thread.sleep(millis);
      } catch (InterruptedException wontHappen) {
        throw new AssertionError();
      }

    }
  }

  private static void assertNotInterrupted() {
    assertFalse(Thread.interrupted());
  }

  private static void requestInterruptIn(long millis) {
    InterruptionUtil.requestInterruptIn(millis, MILLISECONDS);
  }

  @CanIgnoreReturnValue
  private static Thread acquireFor(final Lock lock, final long duration, final TimeUnit unit) {

 * transformation in which case {@code x} has a constant value for all {@code y}. In the
 * non-vertical case, {@code m} is the slope of the transformation (and a horizontal transformation
 * has zero slope).
 *
 * @author Pete Gillin
 * @since 20.0
 */
@J2ktIncompatible
@GwtIncompatible
@ElementTypesAreNonnullByDefault
public abstract class LinearTransformation {

  /**

      BigInteger.valueOf(Long.MAX_VALUE)
          .multiply(BigInteger.valueOf(Long.MAX_VALUE))
          .divide(BigInteger.valueOf(16L))
          .doubleValue();

  /**
   * Returns a stream of a million primitive doubles. The stream is parallel, which should cause
   * {@code collect} calls to run in multithreaded mode, so testing the combiner as well as the
   * supplier and accumulator.
   */

import java.util.List;

/**
 * Inputs, expected outputs, and helper methods for tests of {@link StatsAccumulator}, {@link
 * Stats}, {@link PairedStatsAccumulator}, and {@link PairedStats}.
 *
 * @author Pete Gillin
 */
class StatsTesting {
  // TODO(cpovirk): Convince myself that this larger error makes sense.
  static final double ALLOWED_ERROR = isAndroid() ? .25 : 1e-10;

  // Inputs and their statistics:

    }
  }

  private static void assertNotInterrupted() {
    assertFalse(Thread.interrupted());
  }

  private static void requestInterruptIn(long millis) {
    InterruptionUtil.requestInterruptIn(millis, MILLISECONDS);
  }

  @CanIgnoreReturnValue
  private static Thread acquireFor(final Lock lock, final long duration, final TimeUnit unit) {

 *
 * <p>Basic usage:
 *
 * <pre>{@code
 * Stopwatch stopwatch = Stopwatch.createStarted();
 * doSomething();
 * stopwatch.stop(); // optional
 *
 * long millis = stopwatch.elapsed(MILLISECONDS);
 *
 * log.info("time: " + stopwatch); // formatted string like "12.3 ms"
 * }</pre>
 *
 * <p>The state-changing methods are not idempotent; it is an error to start or stop a stopwatch