boolean langFirst = "lang".equals(keys[0]);
        assertTrue("lang should be first or sorted normally", langFirst || Arrays.asList(keys).contains("lang"));

        assertTrue(Arrays.asList(keys).contains("apple"));
        assertTrue(Arrays.asList(keys).contains("banana"));
        assertTrue(Arrays.asList(keys).contains("zebra"));
    }

    public void test_entrySet_with_lang_key_ordering() {

  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);
  }

      return ImmutableSet.copyOf(elements).asList();
    }
  }

  public static class ImmutableSortedSetAsListGenerator extends TestStringListGenerator {
    @Override
    protected List<String> create(String[] elements) {
      Comparator<String> comparator = createExplicitComparator(elements);
      ImmutableSet<String> set = ImmutableSortedSet.copyOf(comparator, asList(elements));
      return set.asList();
    }
  }

  }

  @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:

  abstract static class CachingAsList<E> extends ImmutableSet<E> {
    @LazyInit private transient ImmutableList<E> asList;

    @Override
    public ImmutableList<E> asList() {
      ImmutableList<E> result = asList;
      if (result == null) {
        return asList = createAsList();
      } else {
        return result;
      }
    }

    @Override
    ImmutableList<E> createAsList() {

        BsUser entity1 = new BsUser();
        entity1.setName("name1");

        BsUser entity2 = new BsUser();
        entity2.setName("name2");

        List<BsUser> entityList = Arrays.asList(entity1, entity2);

        RenderDataUtil.register(data, "entities", entityList);

        Object result = data.getDataMap().get("entities");
        assertNotNull(result);
        assertTrue(result instanceof List);

import static com.google.common.collect.testing.features.CollectionSize.ZERO;
import static com.google.common.collect.testing.google.ReflectionFreeAssertThrows.assertThrows;
import static java.util.Arrays.asList;

import com.google.common.annotations.GwtCompatible;
import com.google.common.annotations.GwtIncompatible;
import com.google.common.annotations.J2ktIncompatible;
import com.google.common.collect.testing.WrongType;

     * contains(null).
     */
    List<E> disjointList = asList(e3(), e4());
    disjoint = new Target(disjointList, "disjoint");
    superset = new Target(MinimalCollection.of(e0(), e1(), e2(), e3(), e4()), "superset");
    nonEmptyProperSubset = new Target(MinimalCollection.of(e1()), "subset");
    sameElements = new Target(asList(createSamplesArray()), "sameElements");
    containsDuplicates =

 * Collections.unmodifiableList}'s iterator:
 *
 * {@snippet :
 * List<String> expectedElements =
 *     Arrays.asList("a", "b", "c", "d", "e");
 * List<String> actualElements =
 *     Collections.unmodifiableList(
 *         Arrays.asList("a", "b", "c", "d", "e"));
 * IteratorTester<String> iteratorTester =
 *     new IteratorTester<String>(
 *         6,
 *         IteratorFeature.UNMODIFIABLE,

  // Test all creation paths very lazily: by assuming asList() works

  public void testOf0() {
    assertThat(ImmutableLongArray.of().asList()).isEmpty();
  }

  public void testOf1() {
    assertThat(ImmutableLongArray.of(0).asList()).containsExactly(0L);
  }

  public void testOf2() {
    assertThat(ImmutableLongArray.of(0, 1).asList()).containsExactly(0L, 1L).inOrder();
  }

  public void testOf3() {