*
   * @param values a series of values, which will be converted to {@code double} values (this may
   *     cause loss of precision for longs of magnitude over 2^53 (slightly over 9e15))
   */
  public static Stats of(long... values) {
    StatsAccumulator accumulator = new StatsAccumulator();
    accumulator.addAll(values);
    return accumulator.snapshot();
  }

  /**

     * Test FileEndOfFileInformation with various end of file values
     */
    @ParameterizedTest
    @ValueSource(longs = { 0L, 1L, -1L, Long.MAX_VALUE, Long.MIN_VALUE, 1024L, 1048576L })
    @DisplayName("Test FileEndOfFileInformation with various values")
    void testFileEndOfFileInformationWithVariousValues(long endOfFile) throws SMBProtocolDecodingException {
        FileEndOfFileInformation fileInfo = new FileEndOfFileInformation(endOfFile);

          "Quantile indexes must be between 0 and the scale, which is " + scale);
    }
  }

  private static double[] longsToDoubles(long[] longs) {
    int len = longs.length;
    double[] doubles = new double[len];
    for (int i = 0; i < len; i++) {
      doubles[i] = longs[i];
    }
    return doubles;
  }

  private static double[] intsToDoubles(int[] ints) {
    int len = ints.length;

    List<Long> longs = Arrays.asList(0L, 1L, 2L);
    List<Double> doubles = Arrays.asList(0.0, 1.0, 2.0);

    assertThat(Bytes.toArray(bytes)).isEqualTo(array);
    assertThat(Bytes.toArray(shorts)).isEqualTo(array);
    assertThat(Bytes.toArray(ints)).isEqualTo(array);
    assertThat(Bytes.toArray(floats)).isEqualTo(array);
    assertThat(Bytes.toArray(longs)).isEqualTo(array);

        .isNull();
    assertWithMessage("Max long").that(Ints.tryParse(Long.toString(Long.MAX_VALUE))).isNull();
    assertWithMessage("Min long").that(Ints.tryParse(Long.toString(Long.MIN_VALUE))).isNull();
    assertThat(Ints.tryParse("\u0662\u06f3")).isNull();
  }

  /**
   * Applies {@link Ints#tryParse(String)} to the given string and asserts that the result is as
   * expected.

   * {@code expectedInsertions} that was used when constructing the filter.
   *
   * @since 22.0
   */
  public long approximateElementCount() {
    long bitSize = bits.bitSize();
    long bitCount = bits.bitCount();

    /*
     * Each insertion is expected to reduce the # of clear bits by a factor of

    List<Long> longs = Arrays.asList(0L, 1L, 2L);
    List<Double> doubles = Arrays.asList(0.0, 1.0, 2.0);

    assertThat(Doubles.toArray(bytes)).isEqualTo(array);
    assertThat(Doubles.toArray(shorts)).isEqualTo(array);
    assertThat(Doubles.toArray(ints)).isEqualTo(array);
    assertThat(Doubles.toArray(floats)).isEqualTo(array);
    assertThat(Doubles.toArray(longs)).isEqualTo(array);

   *
   * @param values a series of values, which will be converted to {@code double} values (this may
   *     cause loss of precision for longs of magnitude over 2^53 (slightly over 9e15))
   */
  public void addAll(long... values) {
    for (long value : values) {
      add(value);
    }
  }

  /**
   * Adds the given values to the dataset. The stream will be completely consumed by this method.

            assertTrue(testRequest.isResponseAsync());
        }

        @ParameterizedTest
        @ValueSource(longs = { 1L, 100L, Long.MAX_VALUE })
        @DisplayName("isResponseAsync should return true for various non-zero asyncIds")
        void testIsResponseAsyncWithDifferentValues(long asyncId) {
            testRequest.setAsyncId(asyncId);
            assertTrue(testRequest.isResponseAsync());
        }
    }

    // Iteratively multiply the longs as big as they can go.
    for (long num = startingNumber; num <= n; num++) {
      // Check to see if the floor(log2(num)) + 1 has changed.
      if ((num & nextPowerOfTwo) != 0) {
        nextPowerOfTwo <<= 1;
        bits++;
      }
      // Get rid of the 2s in num.
      int tz = Long.numberOfTrailingZeros(num);
      long normalizedNum = num >> tz;
      shift += tz;