List<V> list = multimap().get(k0());
    multimap().remove(k0(), v0());
    assertContentsInOrder(list, v1(), v0());
  }

  @MapFeature.Require(SUPPORTS_REMOVE)
  @CollectionSize.Require(SEVERAL)
  public void testRemoveAtIndexFromGetPropagates() {
    List<V> values = asList(v0(), v1(), v0());

    for (int i = 0; i < 3; i++) {

                })
                .collect(toList());
    }

    static class ScenarioBuilder {
        private String description;
        private List<String> activeRequiredProjects = emptyList();
        private List<String> activeOptionalProjects = emptyList();
        private List<String> inactiveRequiredProjects = emptyList();
        private List<String> inactiveOptionalProjects = emptyList();

    @Override
    protected List<String> create(String[] elements) {
      return ImmutableList.<String>builder().addAll(asList(elements)).build();
    }
  }

  public static class BuilderReversedListGenerator extends TestStringListGenerator {
    @Override
    protected List<String> create(String[] elements) {
      List<String> list = asList(elements);
      Collections.reverse(list);

  }

  public void testToArray_withNull() {
    List<@Nullable Integer> list = Arrays.asList((int) 0, (int) 1, null);
    assertThrows(NullPointerException.class, () -> Ints.toArray(list));
  }

  public void testToArray_withConversion() {
    int[] array = {0, 1, 2};

    List<Byte> bytes = Arrays.asList((byte) 0, (byte) 1, (byte) 2);
    List<Short> shorts = Arrays.asList((short) 0, (short) 1, (short) 2);

      }
      return builder.build().keySet().asList();
    }

    @Override
    public List<String> order(List<String> insertionOrder) {
      return Ordering.<String>natural().sortedCopy(insertionOrder);
    }
  }

  public static class ImmutableSortedMapValueListGenerator extends TestStringListGenerator {
    @Override
    protected List<String> create(String[] elements) {

  public ArrayTableColumnMapTest() {
    super(true, false, false, false);
  }

  @Override
  Table<Integer, String, Character> makeTable() {
    return ArrayTable.create(asList(1, 2, 3), asList("foo", "bar", "dog"));
  }

  @Override
  protected Map<String, Map<Integer, Character>> makeEmptyMap() {
    throw new UnsupportedOperationException();
  }

  public ArrayTableRowMapTest() {
    super(true, false, false, false);
  }

  @Override
  Table<String, Integer, Character> makeTable() {
    return ArrayTable.create(asList("foo", "bar", "dog"), asList(1, 2, 3));
  }

  @Override
  protected Map<String, Map<Integer, Character>> makeEmptyMap() {
    throw new UnsupportedOperationException();
  }

  static final LegacyComparable Y = new LegacyComparable("y");
  static final LegacyComparable Z = new LegacyComparable("z");

  static final Iterable<LegacyComparable> VALUES_FORWARD = asList(X, Y, Z);
  static final Iterable<LegacyComparable> VALUES_BACKWARD = asList(Z, Y, X);

  private final String value;

  LegacyComparable(String value) {
    this.value = value;
  }

  @Override
  public int compareTo(Object object) {

@NullUnmarked
public class MapsMemoryBenchmark {
  static final Map<String, MapsImplEnum> mapEnums =
      uniqueIndex(
          Iterables.<MapsImplEnum>concat(
              asList(MapImpl.values()), asList(SortedMapImpl.values()), asList(BiMapImpl.values())),
          toStringFunction());

  @Param({
    "HashMapImpl",
    "LinkedHashMapImpl",
    "ConcurrentHashMapImpl",
    "CompactHashMapImpl",

  public ArrayTableRowMapTest() {
    super(true, false, false, false);
  }

  @Override
  Table<String, Integer, Character> makeTable() {
    return ArrayTable.create(asList("foo", "bar", "dog"), asList(1, 2, 3));
  }

  @Override
  protected Map<String, Map<Integer, Character>> makeEmptyMap() {
    throw new UnsupportedOperationException();
  }