.maximumSize(MAX_SIZE)
            .removalListener(removalListener)
            .build(loader);
    for (int i = 0; i < 2 * MAX_SIZE; i++) {
      cache.getUnchecked(i);
      assertThat(cache.size()).isAtMost(MAX_SIZE);
    }

    assertThat(CacheTesting.accessQueueSize(cache)).isEqualTo(MAX_SIZE);
    assertThat(cache.size()).isEqualTo(MAX_SIZE);
    CacheTesting.processPendingNotifications(cache);

    for (BigInteger x : POSITIVE_BIGINTEGER_CANDIDATES) {
      BigInteger result = BigIntegerMath.floorPowerOfTwo(x);
      assertTrue(BigIntegerMath.isPowerOfTwo(result));
      assertThat(result).isAtMost(x);
      assertThat(result.add(result)).isGreaterThan(x);
    }
  }

  public void testCeilingPowerOfTwoNegative() {
    for (BigInteger x : NEGATIVE_BIGINTEGER_CANDIDATES) {

            .maximumSize(MAX_SIZE)
            .removalListener(removalListener)
            .build(loader);
    for (int i = 0; i < 2 * MAX_SIZE; i++) {
      cache.getUnchecked(i);
      assertThat(cache.size()).isAtMost(MAX_SIZE);
    }

    assertThat(CacheTesting.accessQueueSize(cache)).isEqualTo(MAX_SIZE);
    assertThat(cache.size()).isEqualTo(MAX_SIZE);
    CacheTesting.processPendingNotifications(cache);

    }

    for (CharSource in : BROKEN_SOURCES) {
      for (CharSink out : BROKEN_SINKS) {
        int suppressed = runSuppressionFailureTest(in, out);
        assertThat(suppressed).isAtMost(1);
      }
    }
  }

  /**
   * @return the number of exceptions that were suppressed on the expected thrown exception
   */
  private static int runSuppressionFailureTest(CharSource in, CharSink out) {

      // make sure we time out
      Stopwatch timer = Stopwatch.createStarted();

      int drained = drain(q, new ArrayList<>(), 2, 10, MILLISECONDS, interruptibly);
      assertThat(drained).isAtMost(1);

      assertThat(timer.elapsed(MILLISECONDS)).isAtLeast(10L);

      // If even the first one wasn't there, clean up so that the next test doesn't see an element.
      producerThread.cancel(true);

    }

    for (ByteSource in : BROKEN_SOURCES) {
      for (ByteSink out : BROKEN_SINKS) {
        int suppressed = runSuppressionFailureTest(in, out);
        assertThat(suppressed).isAtMost(1);
      }
    }
  }

  public void testSlice_returnEmptySource() {
    assertEquals(ByteSource.empty(), source.slice(0, 3).slice(4, 3));
  }

  /**

   * Set#size()} of at most {@code max}.
   */
  private static void assertMaxSize(SetView<?> set, int max) {
    assertThat(set.maxSize()).isEqualTo(max);
    assertThat(set.size()).isAtMost(max);
  }

  /**
   * A {@link Set} that throws {@link NullPointerException} and {@link ClassCastException} from
   * {@link #contains}.
   */

    }

    for (ByteSource in : BROKEN_SOURCES) {
      for (ByteSink out : BROKEN_SINKS) {
        int suppressed = runSuppressionFailureTest(in, out);
        assertThat(suppressed).isAtMost(1);
      }
    }
  }

  public void testSlice_returnEmptySource() {
    assertEquals(ByteSource.empty(), source.slice(0, 3).slice(4, 3));
  }

  /**

      countRemaps(r.nextLong(), map);
    }
    for (int shard = 2; shard <= MAX_SHARDS; shard++) {
      // Rough: don't exceed 1.2x the expected number of remaps by more than 20
      assertThat((double) map.get(shard)).isAtMost(1.2 * ITERS / shard + 20);
    }
  }

  private void countRemaps(long h, AtomicLongMap<Integer> map) {
    int last = 0;
    for (int shards = 2; shards <= MAX_SHARDS; shards++) {

  public void testConstantsMaxFactorial() {
    BigInteger maxDoubleValue = BigDecimal.valueOf(Double.MAX_VALUE).toBigInteger();
    assertThat(BigIntegerMath.factorial(DoubleMath.MAX_FACTORIAL)).isAtMost(maxDoubleValue);
    assertThat(BigIntegerMath.factorial(DoubleMath.MAX_FACTORIAL + 1))
        .isGreaterThan(maxDoubleValue);
  }

  public void testConstantsEverySixteenthFactorial() {