public void testAsList_subList_toArray_roundTrip() {
    int[] array = {(int) 0, (int) 1, (int) 2, (int) 3};
    List<Integer> list = Ints.asList(array);
    assertThat(Ints.toArray(list.subList(1, 3))).isEqualTo(new int[] {(int) 1, (int) 2});
    assertThat(Ints.toArray(list.subList(2, 2))).isEqualTo(new int[] {});
  }

  // `primitives` can't depend on `collect`, so this is what the prod code has to return.

    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")
  public void testAsListEmpty() {
    assertThat(Floats.asList(EMPTY)).isSameInstanceAs(Collections.emptyList());

    entries[0] = entry(k1(), v0());
    return entries;
  }

  private void expectFirstRemoved(Entry<K, V>[] entries) {
    resetMap(entries);

    List<Entry<K, V>> expectedWithDuplicateRemoved = asList(entries).subList(1, getNumElements());
    expectContents(expectedWithDuplicateRemoved);
  }

  /**
   * Returns the {@link Method} instance for {@link #testCreateWithNullKeyUnsupported()} so that

   */
  public List<Long> asList() {
    /*
     * Typically we cache this kind of thing, but much repeated use of this view is a performance
     * anti-pattern anyway. If we cache, then everyone pays a price in memory footprint even if
     * they never use this method.
     */
    return new AsList(this);
  }

  private static final class AsList extends AbstractList<Long>

   */
  public List<Integer> asList() {
    /*
     * Typically we cache this kind of thing, but much repeated use of this view is a performance
     * anti-pattern anyway. If we cache, then everyone pays a price in memory footprint even if
     * they never use this method.
     */
    return new AsList(this);
  }

  private static final class AsList extends AbstractList<Integer>

 *         .limit(10)
 *         .toList();
 * }
 *
 * The approximate stream equivalent is:
 *
 * {@snippet :
 * List<String> results =
 *     database.getClientList()
 *         .stream()
 *         .filter(Client::isActiveInLastMonth)
 *         .map(Object::toString)
 *         .limit(10)
 *         .collect(Collectors.toList());
 * }
 *
 * @author Marcin Mikosik

 *         .limit(10)
 *         .toList();
 * }
 *
 * The approximate stream equivalent is:
 *
 * {@snippet :
 * List<String> results =
 *     database.getClientList()
 *         .stream()
 *         .filter(Client::isActiveInLastMonth)
 *         .map(Object::toString)
 *         .limit(10)
 *         .collect(Collectors.toList());
 * }
 *
 * @author Marcin Mikosik
 * @since 12.0

          if (keys.get(i) < keys.get(minIndex)) {
            minIndex = i;
          }
        }
        Optional<BinaryNode> leftChild = createTreap(keys.subList(0, minIndex));
        Optional<BinaryNode> rightChild = createTreap(keys.subList(minIndex + 1, keys.size()));
        return Optional.of(new BinaryNode(keys.get(minIndex), leftChild, rightChild));
      }
    };

    }
    return sum;
  }

  private enum SubMultisetSpec {
    TAIL_CLOSED {
      @Override
      <E> List<Entry<E>> expectedEntries(int targetEntry, List<Entry<E>> entries) {
        return entries.subList(targetEntry, entries.size());
      }

      @Override
      <E> SortedMultiset<E> subMultiset(
          SortedMultiset<E> multiset, List<Entry<E>> entries, int targetEntry) {

  private static final SparseImmutableTable<Character, Integer, String> SPARSE =
      new SparseImmutableTable<>(CELLS.asList(), ROW_SPACE, COLUMN_SPACE);

  private static final DenseImmutableTable<Character, Integer, String> DENSE =
      new DenseImmutableTable<>(CELLS.asList(), ROW_SPACE, COLUMN_SPACE);

  @Override
  Iterable<ImmutableTable<Character, Integer, String>> getTestInstances() {