long[] dataset = Longs.toArray(SIXTEEN_SQUARES_LONGS);
    assertThat(Quantiles.scale(10).index(1).compute(dataset))
        .isWithin(ALLOWED_ERROR)
        .of(SIXTEEN_SQUARES_DECILE_1);
    assertThat(dataset).asList().isEqualTo(SIXTEEN_SQUARES_LONGS);
  }

  public void testScale_index_compute_intVarargs() {
    int[] dataset = Ints.toArray(SIXTEEN_SQUARES_INTEGERS);

    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);
    assertThat(Doubles.toArray(doubles)).isEqualTo(array);
  }

    List<Double> doubles = Arrays.asList(0.0, 1.0, 2.0);

    assertThat(Ints.toArray(bytes)).isEqualTo(array);
    assertThat(Ints.toArray(shorts)).isEqualTo(array);
    assertThat(Ints.toArray(ints)).isEqualTo(array);
    assertThat(Ints.toArray(floats)).isEqualTo(array);
    assertThat(Ints.toArray(longs)).isEqualTo(array);
    assertThat(Ints.toArray(doubles)).isEqualTo(array);
  }

                        }
                    }
                }
            }
        }
        return list.toArray(n -> new TextFragment[n]);
    }

    /**
     * Creates text fragments from search queries.
     *
     * @return array of text fragments based on current queries
     */

    assertThat(Chars.toArray(none)).isEqualTo(EMPTY);

    List<Character> one = Arrays.asList((char) 1);
    assertThat(Chars.toArray(one)).isEqualTo(ARRAY1);

    char[] array = {(char) 0, (char) 1, 'A'};

    List<Character> three = Arrays.asList((char) 0, (char) 1, 'A');
    assertThat(Chars.toArray(three)).isEqualTo(array);

    assertThat(Chars.toArray(Chars.asList(array))).isEqualTo(array);
  }

    checkArgument(
        strictlyOrderedElements.length >= 3,
        "strictlyOrderedElements requires at least 3 elements");
    List<T> list = asList(strictlyOrderedElements);

    // for use calling Collection.toArray later
    T[] emptyArray = newArray(strictlyOrderedElements, 0);

    // shoot me, but I didn't want to deal with wildcards through the whole test
    @SuppressWarnings("unchecked")

    checkArgument(
        strictlyOrderedElements.length >= 3,
        "strictlyOrderedElements requires at least 3 elements");
    List<T> list = asList(strictlyOrderedElements);

    // for use calling Collection.toArray later
    T[] emptyArray = newArray(strictlyOrderedElements, 0);

    // shoot me, but I didn't want to deal with wildcards through the whole test
    @SuppressWarnings("unchecked")

      queue[i] = null;
    }
    size = 0;
  }

  @Override
  @J2ktIncompatible // Incompatible return type change. Use inherited (unoptimized) implementation
  public Object[] toArray() {
    Object[] copyTo = new Object[size];
    arraycopy(queue, 0, copyTo, 0, size);
    return copyTo;
  }

  /**

    assertThat(Chars.toArray(none)).isEqualTo(EMPTY);

    List<Character> one = Arrays.asList((char) 1);
    assertThat(Chars.toArray(one)).isEqualTo(ARRAY1);

    char[] array = {(char) 0, (char) 1, 'A'};

    List<Character> three = Arrays.asList((char) 0, (char) 1, 'A');
    assertThat(Chars.toArray(three)).isEqualTo(array);

    assertThat(Chars.toArray(Chars.asList(array))).isEqualTo(array);
  }

      Set<Object> expected = new HashMap<>(cache.asMap()).keySet();
      assertThat(keys).containsExactlyElementsIn(expected);
      assertThat(keys.toArray()).asList().containsExactlyElementsIn(expected);
      assertThat(keys.toArray(new Object[0])).asList().containsExactlyElementsIn(expected);

      new EqualsTester()
          .addEqualityGroup(cache.asMap().keySet(), keys)