}
    }
  }

  @GwtIncompatible // TODO
  public void testSqrtHalfUp() {
    for (BigInteger x : POSITIVE_BIGINTEGER_CANDIDATES) {
      BigInteger result = BigIntegerMath.sqrt(x, HALF_UP);
      BigInteger plusHalfSquared = result.pow(2).add(result).shiftLeft(2).add(ONE);
      BigInteger x4 = x.shiftLeft(2);
      // sqrt(x) < result + 0.5, so 4 * x < (result + 0.5)^2 * 4

    return bigMean.longValueExact();
  }

  private static boolean fitsInLong(BigInteger big) {
    return big.bitLength() <= 63;
  }

  private static final BigInteger MAX_LONG = BigInteger.valueOf(Long.MAX_VALUE);
  private static final BigInteger MIN_LONG = BigInteger.valueOf(Long.MIN_VALUE);

  private static long saturatedCast(BigInteger big) {
    if (big.compareTo(MAX_LONG) > 0) {
      return Long.MAX_VALUE;
    }

          .add(doubleConversionTest + i);
      BigInteger bigI = BigInteger.valueOf(i);
      testBigIntegersBuilder
          .add(bigI)
          .add(BigInteger.valueOf(Long.MAX_VALUE).add(bigI))
          .add(BigInteger.valueOf(Long.MIN_VALUE).add(bigI))
          .add(BigInteger.valueOf(Integer.MAX_VALUE).add(bigI))
          .add(BigInteger.valueOf(Integer.MIN_VALUE).add(bigI))
          .add(BigInteger.ONE.shiftLeft(63).add(bigI))

      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)
          .multiply(BigInteger.valueOf(Integer.MAX_VALUE))
          .divide(BigInteger.valueOf(16L))
          .doubleValue();

        () -> MathPreconditions.checkPositive("BigInteger", BigInteger.ZERO));
  }

  public void testCheckPositive_positiveBigInteger() {
    MathPreconditions.checkPositive("BigInteger", BigInteger.ONE);
  }

  public void testCheckPositive_negativeBigInteger() {
    assertThrows(
        IllegalArgumentException.class,
        () -> MathPreconditions.checkPositive("BigInteger", BigInteger.ZERO.negate()));
  }

        () -> MathPreconditions.checkPositive("BigInteger", BigInteger.ZERO));
  }

  public void testCheckPositive_positiveBigInteger() {
    MathPreconditions.checkPositive("BigInteger", BigInteger.ONE);
  }

  public void testCheckPositive_negativeBigInteger() {
    assertThrows(
        IllegalArgumentException.class,
        () -> MathPreconditions.checkPositive("BigInteger", BigInteger.ZERO.negate()));
  }

   */
  static final ImmutableSet<BigInteger> POSITIVE_BIGINTEGER_CANDIDATES;

  static final Iterable<BigInteger> NEGATIVE_BIGINTEGER_CANDIDATES;

  static final Iterable<BigInteger> NONZERO_BIGINTEGER_CANDIDATES;

  static final Iterable<BigInteger> ALL_BIGINTEGER_CANDIDATES;

  static {
    ImmutableSet.Builder<BigInteger> bigValues = ImmutableSet.builder();

    checkBigIntegerConversion(
        "255.255.255.254", BigInteger.valueOf(Integer.MAX_VALUE).multiply(BigInteger.valueOf(2)));
    checkBigIntegerConversion(
        "255.255.255.255", BigInteger.ONE.shiftLeft(32).subtract(BigInteger.ONE));
  }

  public void testFromIpv6BigIntegerValid() {
    checkBigIntegerConversion("::", BigInteger.ZERO);
    checkBigIntegerConversion("::1", BigInteger.ONE);

        .that(Longs.tryParse(BigInteger.valueOf(MAX_VALUE).add(BigInteger.ONE).toString()))
        .isNull();
    assertWithMessage("Max long * 10")
        .that(Longs.tryParse(BigInteger.valueOf(MAX_VALUE).multiply(BigInteger.TEN).toString()))
        .isNull();
    assertWithMessage("Min long - 1")
        .that(Longs.tryParse(BigInteger.valueOf(MIN_VALUE).subtract(BigInteger.ONE).toString()))
        .isNull();

      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)
          .multiply(BigInteger.valueOf(Integer.MAX_VALUE))
          .divide(BigInteger.valueOf(16L))
          .doubleValue();