BigIntegerMath.SQRT2_PRECOMPUTED_BITS);
  }

  public void testIsPowerOfTwo() {
    for (BigInteger x : ALL_BIGINTEGER_CANDIDATES) {
      // Checks for a single bit set.
      boolean expected = x.signum() > 0 & x.and(x.subtract(ONE)).equals(ZERO);
      assertEquals(expected, BigIntegerMath.isPowerOfTwo(x));
    }
  }

  public void testLog2ZeroAlwaysThrows() {
    for (RoundingMode mode : ALL_ROUNDING_MODES) {

     * deal with the cases where rounding towards 0 is wrong, which typically depends on the sign of
     * p / q.
     *
     * signum is 1 if p and q are both nonnegative or both negative, and -1 otherwise.
     */
    int signum = 1 | (int) ((p ^ q) >> (Long.SIZE - 1));
    boolean increment;
    switch (mode) {
      case UNNECESSARY:

  @SuppressWarnings("InlineMeInliner")
  public void testCompare() {
    for (char x : VALUES) {
      for (char y : VALUES) {
        assertWithMessage("%s, %s", x, y)
            .that(Math.signum(Chars.compare(x, y)))
            .isEqualTo(Math.signum(Character.compare(x, y)));
      }
    }
  }

  public void testContains() {
    assertThat(Chars.contains(EMPTY, (char) 1)).isFalse();

    @Override
    double roundToDoubleArbitrarily(BigInteger bigInteger) {
      return DoubleUtils.bigToDouble(bigInteger);
    }

    @Override
    int sign(BigInteger bigInteger) {
      return bigInteger.signum();
    }

    @Override
    BigInteger toX(double d, RoundingMode mode) {
      return DoubleMath.roundToBigInteger(d, mode);
    }

    @Override

   *
   * @throws IllegalArgumentException if {@code value} is negative or {@code value >= 2^32}
   */
  public static UnsignedInteger valueOf(BigInteger value) {
    checkNotNull(value);
    checkArgument(
        value.signum() >= 0 && value.bitLength() <= Integer.SIZE,
        "value (%s) is outside the range for an unsigned integer value",
        value);
    return fromIntBits(value.intValue());
  }

  /**

   */
  @CanIgnoreReturnValue
  public static UnsignedLong valueOf(BigInteger value) {
    checkNotNull(value);
    checkArgument(
        value.signum() >= 0 && value.bitLength() <= Long.SIZE,
        "value (%s) is outside the range for an unsigned long value",
        value);
    return fromLongBits(value.longValue());
  }

  /**

        int expected = DoubleMath.fuzzyEquals(a, b, tolerance) ? 0 : Double.compare(a, b);
        int actual = DoubleMath.fuzzyCompare(a, b, tolerance);
        assertEquals(Integer.signum(expected), Integer.signum(actual));
      }
    }
  }

  public void testFuzzyCompareBadTolerance() {
    for (double tolerance : BAD_TOLERANCE_CANDIDATES) {

  public void testIsPowerOfTwo() {
    for (int x : ALL_INTEGER_CANDIDATES) {
      // Checks for a single bit set.
      BigInteger bigX = BigInteger.valueOf(x);
      boolean expected = (bigX.signum() > 0) && (bigX.bitCount() == 1);
      assertEquals(expected, IntMath.isPowerOfTwo(x));
    }
  }

  public void testLog2ZeroAlwaysThrows() {
    for (RoundingMode mode : ALL_ROUNDING_MODES) {

   *     or IPv6 respectively
   */
  private static InetAddress fromBigInteger(BigInteger address, boolean isIpv6) {
    checkArgument(address.signum() >= 0, "BigInteger must be greater than or equal to 0");

    int numBytes = isIpv6 ? 16 : 4;

    byte[] addressBytes = address.toByteArray();
    byte[] targetCopyArray = new byte[numBytes];

   *     or IPv6 respectively
   */
  private static InetAddress fromBigInteger(BigInteger address, boolean isIpv6) {
    checkArgument(address.signum() >= 0, "BigInteger must be greater than or equal to 0");

    int numBytes = isIpv6 ? 16 : 4;

    byte[] addressBytes = address.toByteArray();
    byte[] targetCopyArray = new byte[numBytes];