removeFromReplica(replica, replicatedMinValue);
  }

  private static void removeMaxFromReplica(
      SortedMap<Integer, AtomicInteger> replica, int maxValue) {
    Integer replicatedMaxValue = replica.lastKey();
    assertTrue("maxValue is incorrect", replicatedMaxValue == maxValue);
    removeFromReplica(replica, replicatedMaxValue);
  }

  private static void removeFromReplica(Map<Integer, AtomicInteger> replica, int value) {

    removeFromReplica(replica, replicatedMinValue);
  }

  private static void removeMaxFromReplica(
      SortedMap<Integer, AtomicInteger> replica, int maxValue) {
    Integer replicatedMaxValue = replica.lastKey();
    assertTrue("maxValue is incorrect", replicatedMaxValue == maxValue);
    removeFromReplica(replica, replicatedMaxValue);
  }

  private static void removeFromReplica(Map<Integer, AtomicInteger> replica, int value) {

      throw new IllegalArgumentException(
          "Neither the DiscreteDomain nor this range set are bounded below");
    } else if (!span.hasUpperBound()) {
      try {
        domain.maxValue();
      } catch (NoSuchElementException e) {
        throw new IllegalArgumentException(
            "Neither the DiscreteDomain nor this range set are bounded above");
      }
    }

      throw new IllegalArgumentException(
          "Neither the DiscreteDomain nor this range set are bounded below");
    } else if (!span.hasUpperBound()) {
      try {
        domain.maxValue();
      } catch (NoSuchElementException e) {
        throw new IllegalArgumentException(
            "Neither the DiscreteDomain nor this range set are bounded above");
      }
    }

    BigDecimal maxDoubleAsBigDecimal = new BigDecimal(Double.MAX_VALUE);
    new RoundToDoubleTester(maxDoubleAsBigDecimal)
        .setExpectation(Double.MAX_VALUE, RoundingMode.values())
        .test();
  }

  public void testRoundToDouble_maxDoublePlusOne() {
    BigDecimal maxDoubleAsBigDecimal = new BigDecimal(Double.MAX_VALUE).add(BigDecimal.ONE);
    new RoundToDoubleTester(maxDoubleAsBigDecimal)

   * {@code Integer.MAX_VALUE} or {@code Integer.MIN_VALUE} is returned, respectively.
   *
   * @since 20.0
   */
  public static int saturatedAdd(int a, int b) {
    return Ints.saturatedCast((long) a + b);
  }

  /**
   * Returns the difference of {@code a} and {@code b} unless it would overflow or underflow in

  static final int[] LARGE_INTEGER_VALUES = {Integer.MAX_VALUE, Integer.MAX_VALUE / 2};
  static final double LARGE_INTEGER_VALUES_MEAN =
      BigInteger.valueOf(Integer.MAX_VALUE)
          .multiply(BigInteger.valueOf(3L))
          .divide(BigInteger.valueOf(4L))
          .doubleValue();
  static final double LARGE_INTEGER_VALUES_POPULATION_VARIANCE =
      BigInteger.valueOf(Integer.MAX_VALUE)

    BigDecimal maxDoubleAsBigDecimal = new BigDecimal(Double.MAX_VALUE);
    new RoundToDoubleTester(maxDoubleAsBigDecimal)
        .setExpectation(Double.MAX_VALUE, RoundingMode.values())
        .test();
  }

  public void testRoundToDouble_maxDoublePlusOne() {
    BigDecimal maxDoubleAsBigDecimal = new BigDecimal(Double.MAX_VALUE).add(BigDecimal.ONE);
    new RoundToDoubleTester(maxDoubleAsBigDecimal)

    assertThrows(IllegalArgumentException.class, () -> MathPreconditions.checkPositive("int", 0));
  }

  public void testCheckPositive_maxInt() {
    MathPreconditions.checkPositive("int", Integer.MAX_VALUE);
  }

  public void testCheckPositive_minInt() {
    assertThrows(
        IllegalArgumentException.class,
        () -> MathPreconditions.checkPositive("int", Integer.MIN_VALUE));
  }

    ms.add("a", Integer.MAX_VALUE);
    ms.add("b", Integer.MAX_VALUE);
    ms.add("c", 3);

    assertEquals(Integer.MAX_VALUE, ms.count("a"));
    assertEquals(Integer.MAX_VALUE, ms.count("b"));
    assertEquals(3, ms.count("c"));

    assertEquals(Integer.MAX_VALUE, ms.headMultiset("c", CLOSED).size());
    assertEquals(Integer.MAX_VALUE, ms.headMultiset("b", CLOSED).size());