* values are even integers; this method returns the one that is a multiple of a greater power of
   * two.)
   *
   * @throws ArithmeticException if {@code mode} is {@link RoundingMode#UNNECESSARY} and {@code x}
   *     is not precisely representable as a {@code double}
   * @since 30.0
   */
  public static double roundToDouble(BigDecimal x, RoundingMode mode) {

        assertWithMessage("Expected roundUnnecessaryShouldThrow call")
            .that(unnecessaryShouldThrow)
            .isTrue();
        assertThrows(
            "Expected ArithmeticException for roundToDouble(" + input + ", UNNECESSARY)",
            ArithmeticException.class,
            () -> BigDecimalMath.roundToDouble(input, UNNECESSARY));
      }
    }
  }

  public void testRoundToDouble_zero() {

   * values are even integers; this method returns the one that is a multiple of a greater power of
   * two.)
   *
   * @throws ArithmeticException if {@code mode} is {@link RoundingMode#UNNECESSARY} and {@code x}
   *     is not precisely representable as a {@code double}
   * @since 30.0
   */
  public static double roundToDouble(BigDecimal x, RoundingMode mode) {

    axesSizeProduct[axes.size()] = 1;
    try {
      for (int i = axes.size() - 1; i >= 0; i--) {
        axesSizeProduct[i] = Math.multiplyExact(axesSizeProduct[i + 1], axes.get(i).size());
      }
    } catch (ArithmeticException e) {
      throw new IllegalArgumentException(
          "Cartesian product too large; must have size at most Integer.MAX_VALUE");
    }
    this.axesSizeProduct = axesSizeProduct;
  }

              ? Double.POSITIVE_INFINITY
              : -Double.MAX_VALUE;
        case UP:
          return roundArbitrarily;
        case UNNECESSARY:
          throw new ArithmeticException(x + " cannot be represented precisely as a double");
      }
    }
    X roundArbitrarilyAsX = toX(roundArbitrarily, RoundingMode.UNNECESSARY);
    int cmpXToRoundArbitrarily = x.compareTo(roundArbitrarilyAsX);

   * @throws IllegalArgumentException if {@code duration} is negative
   * @throws IllegalStateException if {@link #expireAfterWrite} was already set
   * @throws ArithmeticException for durations greater than +/- approximately 292 years
   * @since 33.3.0 (but since 25.0 in the JRE <a
   *     href="https://github.com/google/guava#guava-google-core-libraries-for-java">flavor</a>)
   */

   *
   * <p><b>Java 8+ users:</b> use {@link Long#divideUnsigned(long, long)} instead.
   *
   * @param dividend the dividend (numerator)
   * @param divisor the divisor (denominator)
   * @throws ArithmeticException if divisor is 0
   */
  public static long divide(long dividend, long divisor) {
    if (divisor < 0) { // i.e., divisor >= 2^63:
      if (compare(dividend, divisor) < 0) {
        return 0; // dividend < divisor

   *
   * <p><b>Java 8+ users:</b> use {@link Integer#divideUnsigned(int, int)} instead.
   *
   * @param dividend the dividend (numerator)
   * @param divisor the divisor (denominator)
   * @throws ArithmeticException if divisor is 0
   */
  public static int divide(int dividend, int divisor) {
    return (int) (toLong(dividend) / toLong(divisor));
  }

  /**

    List<Callable<Integer>> l = new ArrayList<>();
    l.add(
        new Callable<Integer>() {
          @Override
          public Integer call() {
            throw new ArithmeticException("/ by zero");
          }
        });
    l.add(null);
    try {
      invokeAnyImpl(e, l, false, 0, NANOSECONDS);
      fail();
    } catch (NullPointerException success) {
    } finally {

   *
   * <p><b>Note:</b> this method is now unnecessary and should be treated as deprecated. Use {@link
   * Math#toIntExact(long)} instead, but be aware that that method throws {@link
   * ArithmeticException} rather than {@link IllegalArgumentException}.
   *
   * @param value any value in the range of the {@code int} type
   * @return the {@code int} value that equals {@code value}