// unless all n are fair game with this k
        assertThrows(
            ArithmeticException.class,
            () -> simpleBinomial(LongMath.biggestSimpleBinomials[k] + 1, k));
      }
    }
    int k = LongMath.biggestSimpleBinomials.length;
    assertThrows(ArithmeticException.class, () -> simpleBinomial(2 * k, k));
  }

  @AndroidIncompatible // slow

          int unused = IntMath.checkedAdd(a, b);
          return true;
        } catch (ArithmeticException e) {
          return false;
        }
      }

      @Override
      public boolean noAddOverflow(long a, long b) {
        try {
          long unused = LongMath.checkedAdd(a, b);
          return true;
        } catch (ArithmeticException e) {
          return false;
        }
      }

      @Override

          int unused = IntMath.checkedAdd(a, b);
          return true;
        } catch (ArithmeticException e) {
          return false;
        }
      }

      @Override
      public boolean noAddOverflow(long a, long b) {
        try {
          long unused = LongMath.checkedAdd(a, b);
          return true;
        } catch (ArithmeticException e) {
          return false;
        }
      }

      @Override

   *
   * @throws IllegalArgumentException if {@code x <= 0}
   * @throws ArithmeticException of the next-higher power of two is not representable as an {@code
   *     int}, i.e. when {@code x > 2^30}
   * @since 20.0
   */
  public static int ceilingPowerOfTwo(int x) {
    checkPositive("x", x);
    if (x > MAX_SIGNED_POWER_OF_TWO) {
      throw new ArithmeticException("ceilingPowerOfTwo(" + x + ") not representable as an int");
    }

        assertTrue(isInBounds);
      } catch (ArithmeticException e) {
        assertFalse(isInBounds);
      }
    }
  }

  @GwtIncompatible // DoubleMath.roundToInt(double, RoundingMode)
  public void testRoundExactFractionalDoubleToIntFails() {
    for (double d : FRACTIONAL_DOUBLE_CANDIDATES) {
      assertThrows(ArithmeticException.class, () -> DoubleMath.roundToInt(d, UNNECESSARY));
    }
  }

    for (int x : POSITIVE_INTEGER_CANDIDATES) {
      for (int m : NEGATIVE_INTEGER_CANDIDATES) {
        assertThrows(ArithmeticException.class, () -> IntMath.mod(x, m));
      }
    }
  }

  public void testModZeroModulusFails() {
    for (int x : ALL_INTEGER_CANDIDATES) {
      assertThrows(ArithmeticException.class, () -> IntMath.mod(x, 0));
    }
  }

  public void testGCD() {

     * @param operation the operation name
     * @throws ArithmeticException if operation would overflow
     */
    public static void validateIntegerAddition(int a, int b, String operation) {
        long result = (long) a + (long) b;
        if (result > Integer.MAX_VALUE || result < Integer.MIN_VALUE) {
            throw new ArithmeticException(operation + " would cause integer overflow: " + a + " + " + b);
        }
    }

    assertThrows(
        ArithmeticException.class, () -> MathPreconditions.checkRoundingUnnecessary(false));
  }

  public void testCheckInRange_success() {
    MathPreconditions.checkInRangeForRoundingInputs(true, 1.0, RoundingMode.UP);
  }

  public void testCheckInRange_failure() {
    ArithmeticException expected =
        assertThrows(
            ArithmeticException.class,

    for (int x : POSITIVE_INTEGER_CANDIDATES) {
      for (int m : NEGATIVE_INTEGER_CANDIDATES) {
        assertThrows(ArithmeticException.class, () -> IntMath.mod(x, m));
      }
    }
  }

  public void testModZeroModulusFails() {
    for (int x : ALL_INTEGER_CANDIDATES) {
      assertThrows(ArithmeticException.class, () -> IntMath.mod(x, 0));
    }
  }

  public void testGCD() {

final class Internal {

  /**
   * Returns the number of nanoseconds of the given duration without throwing or overflowing.
   *
   * <p>Instead of throwing {@link ArithmeticException}, this method silently saturates to either
   * {@link Long#MAX_VALUE} or {@link Long#MIN_VALUE}. This behavior can be useful when decomposing