assertThat(BigIntegerMath.factorial(DoubleMath.MAX_FACTORIAL)).isAtMost(maxDoubleValue);
    assertThat(BigIntegerMath.factorial(DoubleMath.MAX_FACTORIAL + 1))
        .isGreaterThan(maxDoubleValue);
  }

  public void testConstantsEverySixteenthFactorial() {
    for (int i = 0, n = 0; n <= DoubleMath.MAX_FACTORIAL; i++, n += 16) {
      assertThat(DoubleMath.everySixteenthFactorial[i])

    assertThat(entry.getKey()).isEqualTo("foo");
    assertThat(entry.getValue()).containsExactly(1, 3, 7);
    entry = iterator.next();
    assertThat(entry.getKey()).isEqualTo("google");
    assertThat(entry.getValue()).containsExactly(2, 6);
    entry = iterator.next();
    assertThat(entry.getKey()).isEqualTo("tree");
    assertThat(entry.getValue()).containsExactly(0, 4);
  }

  public void testOrderedEntries() {

  }

  public void testFileTraverser_emptyDirectory() throws Exception {
    assertThat(Files.fileTraverser().breadthFirst(rootDir)).containsExactly(rootDir);
  }

  public void testFileTraverser_nonExistingFile() throws Exception {
    File file = new File(rootDir, "file-that-doesnt-exist");

    assertThat(Files.fileTraverser().breadthFirst(file)).containsExactly(file);
  }

  }

  public void testFileTraverser_emptyDirectory() throws Exception {
    assertThat(Files.fileTraverser().breadthFirst(rootDir)).containsExactly(rootDir);
  }

  public void testFileTraverser_nonExistingFile() throws Exception {
    File file = new File(rootDir, "file-that-doesnt-exist");

    assertThat(Files.fileTraverser().breadthFirst(file)).containsExactly(file);
  }

    map.putInstance(Integer.class, null);
    assertThat(map.get(Integer.class)).isNull();
    assertThat(map.getInstance(Integer.class)).isNull();

    map.put(Long.class, null);
    assertThat(map.get(Long.class)).isNull();
    assertThat(map.getInstance(Long.class)).isNull();
  }

  public void testPrimitiveAndWrapper() {
    assertThat(map.getInstance(int.class)).isNull();
    assertThat(map.getInstance(Integer.class)).isNull();

        assertThat(it.hasNext(), is(true));

        final Indexed<String> indexed1 = it.next();
        assertThat(indexed1.getIndex(), is(0));
        assertThat(indexed1.getElement(), is("aaa"));

        final Indexed<String> indexed2 = it.next();
        assertThat(indexed2.getIndex(), is(1));
        assertThat(indexed2.getElement(), is("bbb"));

    return suite;
  }

  public void testAllocArraysDefault() {
    CompactHashSet<Integer> set = CompactHashSet.create();
    assertThat(set.needsAllocArrays()).isTrue();
    assertThat(set.elements).isNull();

    set.add(1);
    assertThat(set.needsAllocArrays()).isFalse();
    assertThat(set.elements).hasLength(CompactHashing.DEFAULT_SIZE);
  }

  public void testAllocArraysExpectedSize() {

          .build(),
      )
    call.execute().use { response ->
      assertThat(response.headers)
        .isEqualTo(headersOf("h1", "v1", "h2", "v2"))
      val responseBody = response.body.source()
      assertThat(responseBody.readUtf8(2)).isEqualTo("ok")
      assertThat(responseBody.exhausted()).isTrue()
      assertThat(response.trailers()).isEqualTo(headersOf("trailers", "boom"))
    }
    body.awaitSuccess()

        assertThat(BeanDescFactory.getBeanDesc(MyBean.class), is(sameInstance(beanDesc)));
    }

    /**
     * @throws Exception
     */
    @Test
    public void testClear() throws Exception {
        final BeanDesc beanDesc = BeanDescFactory.getBeanDesc(MyBean.class);
        BeanDescFactory.clear();

        .build()
    execute(sanUrl).use { response ->
      assertThat(response.code).isEqualTo(200)
      assertThat(response.priorResponse!!.code).isEqualTo(421)
      assertThat(response.body.string()).isEqualTo("after misdirect")
    }
    val c0e0 = server.takeRequest()
    assertThat(c0e0.connectionIndex).isEqualTo(0)
    assertThat(c0e0.exchangeIndex).isEqualTo(0)
    val c0e1 = server.takeRequest()