assertThat(result).isAtLeast(x);
      assertThat(result).isLessThan(x.add(x));
    }
  }

  public void testFloorPowerOfTwo() {
    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);
    }

      assertThat(it.protocol).isEqualTo(Protocol.HTTP_2)
      assertThat(it.handshake!!.tlsVersion).isEqualTo(TlsVersion.TLS_1_3)
    }

    client.connectionPool.evictAll()
    assertEquals(0, client.connectionPool.connectionCount())

    client.newCall(request).execute().use {
      assertThat(it.protocol).isEqualTo(Protocol.HTTP_2)

    assertThat(e).hasCauseThat().isEqualTo(exception);
  }

  public void testCallUninterruptiblyWithTimeout_propagatesReturnValue() throws Exception {
    String result =
        timeLimiter.callUninterruptiblyWithTimeout(
            Callables.returning(RETURN_VALUE), DELAY_MS, MILLISECONDS);

    assertThat(result).isEqualTo(RETURN_VALUE);
  }

        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"));

    byte[] chunk3 = newPreFilledByteArray(20); // More data to file

    out.write(chunk1);
    assertThat(out.getFile()).isNull();

    out.write(chunk2);
    assertThat(out.getFile()).isNotNull();
    assertThat(source.read()).isEqualTo(concat(chunk1, chunk2));

    out.write(chunk3);
    assertThat(source.read()).isEqualTo(concat(chunk1, chunk2, chunk3));

    out.reset();
  }

      Throwable throwable, Class<? extends Throwable> clazz, Object[] params) {
    assertThat(throwable).isInstanceOf(clazz);
    if (params.length == 1) {
      assertThat(throwable).hasMessageThat().isNull();
    } else if (params.length == 2) {
      assertThat(throwable).hasMessageThat().isEmpty();
    } else {
      assertThat(throwable)
          .hasMessageThat()

    LocalCache<?, ?> map = CacheTesting.toLocalCache(cache);

    assertThat(map.segments).hasLength(4);
    assertThat(map.segments[0].table.length()).isEqualTo(2);
    assertThat(map.segments[1].table.length()).isEqualTo(2);
    assertThat(map.segments[2].table.length()).isEqualTo(2);
    assertThat(map.segments[3].table.length()).isEqualTo(2);
  }

  @GwtIncompatible // CacheTesting

      )
    val requestLine = decodeRequestLine("CONNECT example.com:8080 HTTP/1.1")
    val request = RecordedRequest(requestLine, headers, emptyList(), 0, ByteString.EMPTY, 0, 0, socket)
    assertThat(request.target).isEqualTo("example.com:8080")
    assertThat(request.url.toString()).isEqualTo("http://example.com:8080/")
  }

  @Test fun testAbsoluteForm() {
    val socket =
      MockWebServerSocket(
        FakeSocket(

    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() {

        PropertiesUtil.load(properties, file);
        assertThat(properties.getProperty("a"), is("A"));
    }

    /**
     * {@link org.codelibs.core.io.PropertiesUtil#load(Properties, URL)}
     */
    @Test
    public void testLoadPropertiesUrl() {
        final Properties properties = new Properties();
        PropertiesUtil.load(properties, url);
        assertThat(properties.getProperty("a"), is("A"));
    }