Request
        .Builder()
        .url("http://localhost/api")
        .delete()
        .build()
    assertThat(delete.method).isEqualTo("DELETE")
    assertThat(delete.body!!.contentLength()).isEqualTo(0L)

    val post =
      Request
        .Builder()
        .url("http://localhost/api")
        .post(body)
        .build()
    assertThat(post.method).isEqualTo("POST")

      accumulator.addAll(accumulator.snapshot());
    }
    // Should overflow without throwing.
    accumulator.addAll(accumulator.snapshot());
    assertThat(accumulator.count()).isLessThan(0L);
  }

  public void testMean() {
    assertThrows(IllegalStateException.class, () -> emptyAccumulator.mean());
    assertThrows(IllegalStateException.class, () -> emptyAccumulatorByAddAllEmptyIterable.mean());

        if (logger.isDebugEnabled()) {
            logger.debug("Initialized executor thread pool: size={}", nThreads);
        }
        return new ThreadPoolExecutor(nThreads, nThreads, 0L, TimeUnit.MILLISECONDS, new LinkedBlockingQueue<>(nThreads),
                new ThreadPoolExecutor.CallerRunsPolicy());
    }

    @Override

    List<Short> shorts = Arrays.asList((short) 0, (short) 1, (short) 2);
    List<Integer> ints = Arrays.asList(0, 1, 2);
    List<Float> floats = Arrays.asList(0.0f, 1.0f, 2.0f);
    List<Long> longs = Arrays.asList(0L, 1L, 2L);
    List<Double> doubles = Arrays.asList(0.0, 1.0, 2.0);

    assertThat(Shorts.toArray(bytes)).isEqualTo(array);
    assertThat(Shorts.toArray(shorts)).isEqualTo(array);

    point were invalid certificates accepted.
 *  New: `OkHttpClient.Builder.minWebSocketMessageToCompress()` configures a threshold for
    compressing outbound web socket messages. Configure this with 0L to always compress outbound
    messages and `Long.MAX_VALUE` to never compress outbound messages. The default is 1024L which
    compresses messages of size 1 KiB and larger. (Inbound messages are compressed or not based on

            list = (EsPagingResultBean<?>) searchLogBhv.selectPage(cb -> {
                cb.fetchFirst(0);
                createSearchLogCondition(pager, cb);
                cb.query().setHitCount_Equal(0L);
                cb.aggregation().setSearchWord_Terms(SearchLogPager.LOG_TYPE_SEARCH_ZEROHIT, op -> {
                    op.size(pager.getPageSize());
                    if (fessConfig.getSearchlogAggShardSizeAsInteger() >= 0) {

     * stability checks.
     */
    long sum = 0L;
    Segment<K, V>[] segments = this.segments;
    for (Segment<K, V> segment : segments) {
      if (segment.count != 0) {
        return false;
      }
      sum += segment.modCount;
    }

    if (sum != 0L) { // recheck unless no modifications
      for (Segment<K, V> segment : segments) {

    /**
     * Calibrates the CPU load.
     *
     * @return true if the CPU load is within the acceptable range, false otherwise.
     */
    public boolean calibrateCpuLoad() {
        return calibrateCpuLoad(0L);
    }

    /**
     * Calibrates the CPU load with a timeout.
     *
     * @param timeoutInMillis The timeout in milliseconds.

  }

  /** Regression test for https://github.com/google/guava/issues/2658 */
  public void testRemoveRegression() {
    MinMaxPriorityQueue<Long> queue =
        MinMaxPriorityQueue.create(ImmutableList.of(2L, 3L, 0L, 4L, 1L));
    queue.remove(4L);
    queue.remove(1L);
    assertThat(queue).doesNotContain(1L);
  }

  public void testRandomRemoves() {
    Random random = new Random(0);

            bufferedSink.flush();
          }

          public Sink sink(Sink sink) {
            return new ForwardingSink(sink) {
              private long totalBytesWritten = 0L;
              private boolean completed = false;

              @Override public void write(Buffer source, long byteCount) throws IOException {
                super.write(source, byteCount);