public void testCreateFromSortedSetMultimap() {
    SortedSetMultimap<Double, Double> tree = TreeMultimap.create(KEY_COMPARATOR, VALUE_COMPARATOR);
    tree.put(1.0, 2.0);
    tree.put(2.0, 3.0);
    tree.put(3.0, 4.0);
    tree.put(4.0, 5.0);

    SortedSetMultimap<Double, Double> sorted = Multimaps.unmodifiableSortedSetMultimap(tree);
    TreeMultimap<Double, Double> copyFromSorted = TreeMultimap.create(sorted);

    // For datasets of many double values created from an iterable, we test many combinations of
    // finite and non-finite values:
    for (ManyValues values : ALL_MANY_VALUES) {
      StatsAccumulator accumulator = new StatsAccumulator();
      StatsAccumulator accumulatorByAddAllStats = new StatsAccumulator();
      accumulator.addAll(values.asIterable());
      for (double value : values.asIterable()) {

  public void testCheckNonNegative_zeroDouble() {
    MathPreconditions.checkNonNegative("double", 0d);
  }

  public void testCheckNonNegative_maxDouble() {
    MathPreconditions.checkNonNegative("double", Double.MAX_VALUE);
  }

  public void testCheckNonNegative_minDouble() {
    MathPreconditions.checkNonNegative("double", Double.MIN_VALUE);
  }

  public void testCheckNonNegative_positiveDouble() {

    assertThat(ONE_VALUE_PAIRED_STATS.populationCovariance()).isEqualTo(0.0);
    assertThat(createSingleStats(Double.POSITIVE_INFINITY, 1.23).populationCovariance()).isNaN();
    assertThat(createSingleStats(Double.NEGATIVE_INFINITY, 1.23).populationCovariance()).isNaN();
    assertThat(createSingleStats(Double.NaN, 1.23).populationCovariance()).isNaN();
    assertThat(TWO_VALUES_PAIRED_STATS.populationCovariance())

    assertThat(ONE_VALUE_PAIRED_STATS.populationCovariance()).isEqualTo(0.0);
    assertThat(createSingleStats(Double.POSITIVE_INFINITY, 1.23).populationCovariance()).isNaN();
    assertThat(createSingleStats(Double.NEGATIVE_INFINITY, 1.23).populationCovariance()).isNaN();
    assertThat(createSingleStats(Double.NaN, 1.23).populationCovariance()).isNaN();
    assertThat(TWO_VALUES_PAIRED_STATS.populationCovariance())

    }

    public void formatRate(MessageBuilder builder, double rate) {
        // Handle invalid rates gracefully (including negative values)
        if (Double.isNaN(rate) || Double.isInfinite(rate) || rate < 0) {
            builder.append("? B/s");
            return;
        }

        ScaleUnit unit = ScaleUnit.getScaleUnit(Math.round(rate));
        double scaledRate = rate / unit.bytes();

        }

        double scaledSize = (double) size / unit.bytes();

        if (unit == ScaleUnit.BYTE) {
            builder.append(Long.toString(size));
        } else if (scaledSize < 0.05d || scaledSize >= 10.0d) {
            builder.append(Long.toString(Math.round(scaledSize)));
        } else {
            builder.append(Double.toString(Math.round(scaledSize * 10d) / 10d));
        }

        Map<String, Object> map = new HashMap<>();
        map.put("float", 1.5f);
        map.put("double", 2.5d);
        map.put("int", 3);
        map.put("string", "4.5");

        assertEquals(1.5f, MapValueExtractor.getFloat(map, "float"), 0.001f);
        assertEquals(2.5f, MapValueExtractor.getFloat(map, "double"), 0.001f);
        assertEquals(3.0f, MapValueExtractor.getFloat(map, "int"), 0.001f);

   */
  public abstract ComparisonChain compare(float left, float right);

  /**
   * Compares two {@code double} values as specified by {@link Double#compare}, <i>if</i> the result
   * of this comparison chain has not already been determined.
   */
  public abstract ComparisonChain compare(double left, double right);

  /**
   * Discouraged synonym for {@link #compareFalseFirst}.
   *

  public static RateLimiter create(double permitsPerSecond, long warmupPeriod, TimeUnit unit) {
    checkArgument(warmupPeriod >= 0, "warmupPeriod must not be negative: %s", warmupPeriod);
    return create(
        permitsPerSecond, warmupPeriod, unit, 3.0, SleepingStopwatch.createFromSystemTimer());
  }

  @VisibleForTesting
  static RateLimiter create(
      double permitsPerSecond,
      long warmupPeriod,