.setExpectation(-Math.pow(2, 53), DOWN, CEILING, HALF_DOWN, HALF_EVEN)
        .setExpectation(DoubleUtils.nextDown(-Math.pow(2, 53)), FLOOR, UP, HALF_UP)
        .roundUnnecessaryShouldThrow()
        .test();
  }

  public void testRoundToDouble_negativeTwoToThe54MinusOne() {
    new RoundToDoubleTester(BigDecimal.valueOf((-1L << 54) - 1))
        .setExpectation(-Math.pow(2, 54), DOWN, CEILING, HALF_DOWN, HALF_UP, HALF_EVEN)

import static com.google.common.math.MathBenchmarking.ARRAY_MASK;
import static com.google.common.math.MathBenchmarking.ARRAY_SIZE;
import static com.google.common.math.MathBenchmarking.RANDOM_SOURCE;
import static java.math.RoundingMode.CEILING;

import com.google.caliper.BeforeExperiment;
import com.google.caliper.Benchmark;
import com.google.caliper.Param;
import java.math.BigInteger;

/**

  }

  @CollectionSize.Require(SEVERAL)
  public void testCeilingHole() {
    resetWithHole();
    assertEquals(a, navigableSet.ceiling(a));
    assertEquals(c, navigableSet.ceiling(b));
    assertEquals(c, navigableSet.ceiling(c));
  }

  @CollectionSize.Require(SEVERAL)
  public void testHigherHole() {
    resetWithHole();
    assertEquals(c, navigableSet.higher(a));

          return Double.MAX_VALUE * sign(x);
        case FLOOR:
          return (roundArbitrarily == Double.POSITIVE_INFINITY)
              ? Double.MAX_VALUE
              : Double.NEGATIVE_INFINITY;
        case CEILING:
          return (roundArbitrarily == Double.POSITIVE_INFINITY)
              ? Double.POSITIVE_INFINITY
              : -Double.MAX_VALUE;
        case UP:
          return roundArbitrarily;
        case UNNECESSARY:

  }

  @CollectionSize.Require(SEVERAL)
  public void testCeilingHole() {
    resetWithHole();
    assertEquals(a, navigableSet.ceiling(a));
    assertEquals(c, navigableSet.ceiling(b));
    assertEquals(c, navigableSet.ceiling(c));
  }

  @CollectionSize.Require(SEVERAL)
  public void testHigherHole() {
    resetWithHole();
    assertEquals(c, navigableSet.higher(a));

          return Double.MAX_VALUE * sign(x);
        case FLOOR:
          return (roundArbitrarily == Double.POSITIVE_INFINITY)
              ? Double.MAX_VALUE
              : Double.NEGATIVE_INFINITY;
        case CEILING:
          return (roundArbitrarily == Double.POSITIVE_INFINITY)
              ? Double.POSITIVE_INFINITY
              : -Double.MAX_VALUE;
        case UP:
          return roundArbitrarily;
        case UNNECESSARY:

	cases := []struct {
		numerator, denominator, ceiling int64
	}{
		{0, 1, 0},
		{-1, 2, 0},
		{1, 2, 1},
		{1, 1, 1},
		{3, 2, 2},
		{54, 11, 5},
		{45, 11, 5},
		{-4, 3, -1},
		{4, -3, -1},
		{-4, -3, 2},
		{3, 0, 0},
	}
	for i, testCase := range cases {
		ceiling := ceilFrac(testCase.numerator, testCase.denominator)
		if ceiling != testCase.ceiling {

      @SuppressWarnings({"unchecked", "nullness"})
      SortedSet<@Nullable Object> self = (SortedSet<@Nullable Object>) this;
      Object ceiling = self.tailSet(object).first();
      return unsafeCompare(comparator(), ceiling, object) == 0;
    } catch (ClassCastException | NoSuchElementException | NullPointerException e) {
      return false;
    }
  }

  /**

  @CheckForNull
  public E lower(E element) {
    return forward.higher(element);
  }

  @Override
  @CheckForNull
  public E floor(E element) {
    return forward.ceiling(element);
  }

  @Override
  @CheckForNull
  public E ceiling(E element) {
    return forward.floor(element);
  }

  @Override
  @CheckForNull
  public E higher(E element) {
    return forward.lower(element);
  }

   * {@code BigInteger.valueOf(2).pow(log2(x, CEILING))}.
   *
   * @throws IllegalArgumentException if {@code x <= 0}
   * @since 20.0
   */
  public static BigInteger ceilingPowerOfTwo(BigInteger x) {
    return BigInteger.ZERO.setBit(log2(x, CEILING));
  }

  /**
   * Returns the largest power of two less than or equal to {@code x}. This is equivalent to {@code