assertEquals(HashMultiset.create(asList("a", "b", "a", "c")), multiset);
  }

  public void testBuilderAddAll() {
    List<String> a = asList("a", "b");
    List<String> b = asList("c", "d");
    ImmutableMultiset<String> multiset =
        new ImmutableMultiset.Builder<String>().addAll(a).addAll(b).build();
    assertEquals(HashMultiset.create(asList("a", "b", "c", "d")), multiset);
  }

        multimap = LinkedHashMultimap.create();
        multimap.putAll("foo", asList(2, 3));
        multimap.putAll("bar", asList(4, 5));
        multimap.putAll("foo", asList(6));
        multimap.putAll("baz", asList(7, 8));
        multimap.putAll("dog", asList(9));
        multimap.putAll("bar", asList(10, 11));
        multimap.putAll("cat", asList(12, 13, 14));
        return multimap.asMap().entrySet().iterator();
      }

        Sets.newLinkedHashSet(
            asList(
                Maps.immutableEntry("foo", (Collection<Integer>) asList(2, 3, 6)),
                Maps.immutableEntry("bar", (Collection<Integer>) asList(4, 5, 10, 11)),
                Maps.immutableEntry("baz", (Collection<Integer>) asList(7, 8)),
                Maps.immutableEntry("dog", (Collection<Integer>) asList(9)),

            ListTestSuiteBuilder.using(new FloatsAsListTailSubListGenerator())
                .named("Floats.asList, tail subList"),
            ListTestSuiteBuilder.using(new FloatsAsListMiddleSubListGenerator())
                .named("Floats.asList, middle subList"));

    TestSuite suite = new TestSuite();
    for (ListTestSuiteBuilder<Float> builder : builders) {
      suite.addTest(
          builder

    }
    return Longs.asList(temp);
  }

  @J2ktIncompatible
  @GwtIncompatible // suite
  public static Test suite() {
    List<ListTestSuiteBuilder<Long>> builders =
        ImmutableList.of(
            ListTestSuiteBuilder.using(new LongsAsListGenerator()).named("Longs.asList"),
            ListTestSuiteBuilder.using(new LongsAsListHeadSubListGenerator())
                .named("Longs.asList, head subList"),

  }

  public void testCreateDuplicateRows() {
    try {
      ArrayTable.create(asList("foo", "bar", "foo"), asList(1, 2, 3));
      fail();
    } catch (IllegalArgumentException expected) {
    }
  }

  public void testCreateDuplicateColumns() {
    try {
      ArrayTable.create(asList("foo", "bar"), asList(1, 2, 3, 2));
      fail();
    } catch (IllegalArgumentException expected) {
    }
  }

  }

  public void testCreateDuplicateRows() {
    try {
      ArrayTable.create(asList("foo", "bar", "foo"), asList(1, 2, 3));
      fail();
    } catch (IllegalArgumentException expected) {
    }
  }

  public void testCreateDuplicateColumns() {
    try {
      ArrayTable.create(asList("foo", "bar"), asList(1, 2, 3, 2));
      fail();
    } catch (IllegalArgumentException expected) {
    }
  }

    FluentIterable<Integer> result =
        FluentIterable.<Integer>from(asList(1, 2, 3)).append(Lists.newArrayList(4, 5, 6));
    assertEquals(asList(1, 2, 3, 4, 5, 6), Lists.newArrayList(result));
    assertEquals("[1, 2, 3, 4, 5, 6]", result.toString());

    result = FluentIterable.<Integer>from(asList(1, 2, 3)).append(4, 5, 6);
    assertEquals(asList(1, 2, 3, 4, 5, 6), Lists.newArrayList(result));

    assertEquals(asList("a", "b", "a", "c"), list);
  }

  public void testBuilderAddAll_iterable() {
    List<String> a = asList("a", "b");
    List<String> b = asList("c", "d");
    ImmutableList<String> list = new ImmutableList.Builder<String>().addAll(a).addAll(b).build();
    assertEquals(asList("a", "b", "c", "d"), list);
    b.set(0, "f");
    assertEquals(asList("a", "b", "c", "d"), list);
  }

      throw new Error();
    } catch (AssertionFailedError expected) {
    }
  }

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

    List<?> fewer = Arrays.asList("a", "b");
    try {
      Helpers.assertEqualInOrder(list, fewer);
      throw new Error();
    } catch (AssertionFailedError expected) {
    }

    try {