}

  public void testAssertEqualInOrder() {
    List<?> list = asList("a", "b", "c");
    assertEqualInOrder(list, list);

    List<?> fewer = asList("a", "b");
    assertThrows(AssertionFailedError.class, () -> assertEqualInOrder(list, fewer));

    assertThrows(AssertionFailedError.class, () -> assertEqualInOrder(fewer, list));

    List<?> differentOrder = asList("a", "c", "b");

  }

  public void testAssertEqualInOrder() {
    List<?> list = asList("a", "b", "c");
    assertEqualInOrder(list, list);

    List<?> fewer = asList("a", "b");
    assertThrows(AssertionFailedError.class, () -> assertEqualInOrder(list, fewer));

    assertThrows(AssertionFailedError.class, () -> assertEqualInOrder(fewer, list));

    List<?> differentOrder = asList("a", "c", "b");

  }

  private static void assertArrayEquals(String message, Object[] expected, Object[] actual) {
    assertEquals(message, asList(expected), asList(actual));
  }

  public void testStreamToArrayUnknownOrder() {
    assertEqualIgnoringOrder(getSampleElements(), asList(collection.stream().toArray()));
  }

  @CollectionFeature.Require(KNOWN_ORDER)
  public void testStreamToArrayKnownOrder() {
    assertEquals(getOrderedElements(), asList(collection.stream().toArray()));
  }

  public void testStreamCount() {

        ImmutableSetMultimap.<Character, Character>builder()
            .putAll('b', Arrays.asList('a', 'n', 'a', 'n', 'a'))
            .putAll('a', Arrays.asList('p', 'p', 'l', 'e'))
            .putAll('c', Arrays.asList('a', 'r', 'r', 'o', 't'))
            .putAll('a', Arrays.asList('s', 'p', 'a', 'r', 'a', 'g', 'u', 's'))
            .putAll('c', Arrays.asList('h', 'e', 'r', 'r', 'y'))
            .build();

    // need explicit type parameter to avoid javac warning!?
    List<Double> none = Arrays.<Double>asList();
    assertThat(Doubles.toArray(none)).isEqualTo(EMPTY);

    List<Double> one = Arrays.asList(1.0);
    assertThat(Doubles.toArray(one)).isEqualTo(ARRAY1);

    double[] array = {0.0, 1.0, Math.PI};

    List<Double> three = Arrays.asList(0.0, 1.0, Math.PI);
    assertThat(Doubles.toArray(three)).isEqualTo(array);

  public void testReplaceValuesWithNullValue() {
    List<V> values = asList(v0(), null, v3());
    multimap().replaceValues(k0(), values);
    assertGet(k0(), values);
  }

  @MapFeature.Require({SUPPORTS_PUT, SUPPORTS_REMOVE, ALLOWS_NULL_KEYS})
  public void testReplaceValuesWithNullKey() {
    List<V> values = asList(v0(), v2(), v3());
    multimap().replaceValues(null, values);
    assertGet(null, values);
  }

        ImmutableListMultimap.<Character, Character>builder()
            .putAll('b', Arrays.asList('a', 'n', 'a', 'n', 'a'))
            .putAll('a', Arrays.asList('p', 'p', 'l', 'e'))
            .putAll('c', Arrays.asList('a', 'r', 'r', 'o', 't'))
            .putAll('a', Arrays.asList('s', 'p', 'a', 'r', 'a', 'g', 'u', 's'))
            .putAll('c', Arrays.asList('h', 'e', 'r', 'r', 'y'))
            .build();

    // re-order
    getAll(cache, asList(0, 1, 2));
    CacheTesting.drainRecencyQueues(cache);
    assertThat(keySet).containsExactly(3, 4, 5, 6, 7, 8, 9, 0, 1, 2);

    // evict 3, 4, 5
    getAll(cache, asList(10));
    CacheTesting.drainRecencyQueues(cache);
    assertThat(keySet).containsExactly(6, 7, 8, 9, 0, 1, 2, 10);

    // re-order
    getAll(cache, asList(6, 7, 8));

  }

  @Override
  public final void clear() {
    throw new UnsupportedOperationException();
  }

  private transient @Nullable ImmutableList<E> asList;

  public ImmutableList<E> asList() {
    ImmutableList<E> list = asList;
    return (list == null) ? (asList = createAsList()) : list;
  }

  ImmutableList<E> createAsList() {
    switch (size()) {
      case 0:
        return ImmutableList.of();
      case 1: