assertEquals(asList(1, 2), partitions.get(0));
    assertEquals(asList(3), partitions.get(1));
  }

  @J2ktIncompatible // Arrays.asList(...).subList() doesn't implement RandomAccess in J2KT.
  @GwtIncompatible // ArrayList.subList doesn't implement RandomAccess in GWT.
  public void testPartitionRandomAccessTrue() {
    List<Integer> source = asList(1, 2, 3);

  public void testAsList_subList_toArray_roundTrip() {
    float[] array = {0.0f, 1.0f, 2.0f, 3.0f};
    List<Float> list = Floats.asList(array);
    assertThat(Floats.toArray(list.subList(1, 3))).isEqualTo(new float[] {1.0f, 2.0f});
    assertThat(Floats.toArray(list.subList(2, 2))).isEmpty();
  }

  // `primitives` can't depend on `collect`, so this is what the prod code has to return.
  @SuppressWarnings("EmptyList")

   */
  private int findSuffixOfType(Optional<PublicSuffixType> desiredType) {
    int partsSize = parts.size();

    for (int i = 0; i < partsSize; i++) {
      String ancestorName = DOT_JOINER.join(parts.subList(i, partsSize));

      if (i > 0
          && matchesType(
              desiredType, Optional.fromNullable(PublicSuffixPatterns.UNDER.get(ancestorName)))) {
        return i - 1;
      }

        }

        int toIndex = offset + size;
        if (toIndex > stopwordsItemList.size()) {
            toIndex = stopwordsItemList.size();
        }

        return new PagingList<>(stopwordsItemList.subList(offset, toIndex), offset, size, stopwordsItemList.size());
    }

    @Override
    public synchronized void insert(final StopwordsItem item) {
        try (StopwordsUpdater updater = new StopwordsUpdater(item)) {

        upper = middle - 1;
      } else if (c > 0) {
        lower = middle + 1;
      } else {
        return lower
            + presentBehavior.resultIndex(
                comparator, key, list.subList(lower, upper + 1), middle - lower);
      }
    }
    return absentBehavior.resultIndex(lower);
  }

        }

        public ListIterator<E> listIterator(final int index) {
            return parent.listIterator(index);
        }

        public List<E> subList(final int fromIndex, final int toIndex) {
            return parent.subList(fromIndex, toIndex);
        }

        public RequestOptionCall<BulkRequestBuilder> getCall() {
            return call;
        }

        int toIndex = offset + size;
        if (toIndex > stemmerOverrideItemList.size()) {
            toIndex = stemmerOverrideItemList.size();
        }

        return new PagingList<>(stemmerOverrideItemList.subList(offset, toIndex), offset, size, stemmerOverrideItemList.size());
    }

    @Override
    public synchronized void insert(final StemmerOverrideItem item) {

          Object writeReplace() {
            return super.writeReplace();
          }
        };
    ImmutableRangeMap<K, V> outer = this;
    return new ImmutableRangeMap<K, V>(subRanges, values.subList(lowerIndex, upperIndex)) {
      @Override
      public ImmutableRangeMap<K, V> subRangeMap(Range<K> subRange) {
        if (range.isConnected(subRange)) {
          return outer.subRangeMap(subRange.intersection(range));

  }

  /**
   * Reverses the elements of {@code array} between {@code fromIndex} inclusive and {@code toIndex}
   * exclusive. This is equivalent to {@code
   * Collections.reverse(Longs.asList(array).subList(fromIndex, toIndex))}, but is likely to be more
   * efficient.
   *
   * @throws IndexOutOfBoundsException if {@code fromIndex < 0}, {@code toIndex > array.length}, or
   *     {@code toIndex > fromIndex}

        }

        int toIndex = offset + size;
        if (toIndex > kuromojiItemList.size()) {
            toIndex = kuromojiItemList.size();
        }

        return new PagingList<>(kuromojiItemList.subList(offset, toIndex), offset, size, kuromojiItemList.size());
    }

    @Override
    public synchronized void insert(final KuromojiItem item) {
        try (KuromojiUpdater updater = new KuromojiUpdater(item)) {