private static final ImmutableMap<Class<? extends Throwable>, Predicate<Throwable>> INSTANCE_OF =
      ImmutableMap.<Class<? extends Throwable>, Predicate<Throwable>>builder()
          .put(ArithmeticException.class, e -> e instanceof ArithmeticException)
          .put(
              ArrayIndexOutOfBoundsException.class,
              e -> e instanceof ArrayIndexOutOfBoundsException)

          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

@J2ktIncompatible
@GwtIncompatible // java.time.Duration
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

        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));
    }
  }

@J2ktIncompatible
@GwtIncompatible // java.time.Duration
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

        assertEquals(100, InputValidator.safeAdd(50, 50));
        assertEquals(0, InputValidator.safeAdd(-50, 50));

        assertThrows(ArithmeticException.class, () -> InputValidator.safeAdd(Integer.MAX_VALUE, 1));
        assertThrows(ArithmeticException.class, () -> InputValidator.safeAdd(Integer.MIN_VALUE, -1));
    }

    @Test
    @DisplayName("Test safe integer multiplication")

        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));
    }
  }

    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,

  private static final ImmutableMap<Class<? extends Throwable>, Predicate<Throwable>> INSTANCE_OF =
      ImmutableMap.<Class<? extends Throwable>, Predicate<Throwable>>builder()
          .put(ArithmeticException.class, e -> e instanceof ArithmeticException)
          .put(
              ArrayIndexOutOfBoundsException.class,
              e -> e instanceof ArrayIndexOutOfBoundsException)

    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() {