public static class ImmutableListOfGenerator extends TestStringListGenerator {
    @Override
    protected List<String> create(String[] elements) {
      return ImmutableList.copyOf(elements);
    }
  }

  public static class BuilderAddListGenerator extends TestStringListGenerator {
    @Override
    protected List<String> create(String[] elements) {
      ImmutableList.Builder<String> builder = ImmutableList.builder();

    create().isEmpty();
    create().iterator();
    create().remove("foo");
    create().removeAll(ImmutableList.of("foo"));
    create().retainAll(ImmutableList.of("foo"));
    create().size();
    create().toArray();
    create().toArray(new String[] {"foo"});
    create().addFirst("e");
    create().addLast("e");
    create().offerFirst("e");
    create().offerLast("e");
    create().removeFirst();

    private Configuration configuration;

    /**
     * Create an authenticator using the JAAS service <code>jcifs</code>
     *
     * This will require that a keytab is configured in this service.
     *
     *
     */
    public JAASAuthenticator() {
        this("jcifs");
    }

    /**
     * Create an authenticator using the given JAAS service
     *

        .addEqualityGroup(
            getMultiset(), getSubjectGenerator().create(getSampleElements().toArray()))
        .testEquals();
  }

  @CollectionSize.Require(absent = ZERO)
  public void testNotEqualsEmpty() {
    new EqualsTester()
        .addEqualityGroup(getMultiset())
        .addEqualityGroup(getSubjectGenerator().create())
        .testEquals();
  }

  public void testHashCodeMatchesEntrySet() {

    }

    @Override
    public SampleElements<Entry<K, V>> samples() {
      return generator.samples();
    }

    @Override
    public Map<K, V> create(Object... elements) {
      return generator.create(elements);
    }

    @Override
    public Entry<K, V>[] createArray(int length) {
      return generator.createArray(length);
    }

    @Override

  public void testHoldsLockOnAllOperations() {
    create().element();
    create().offer("foo");
    create().peek();
    create().poll();
    create().remove();
    create().add("foo");
    create().addAll(ImmutableList.of("foo"));
    create().clear();
    create().contains("foo");
    create().containsAll(ImmutableList.of("foo"));
    create().equals(new ArrayDeque<>(ImmutableList.of("foo")));

        HashBasedTable.create((Table<String, Integer, ? extends Character>) table);
    Table<String, Integer, C> reordered = create("foo", 3, 'c', "foo", 1, 'a', "bar", 1, 'b');
    Table<String, Integer, C> smaller = create("foo", 1, 'a', "bar", 1, 'b');
    Table<String, Integer, C> swapOuter = create("bar", 1, 'a', "foo", 1, 'b', "bar", 3, 'c');
    Table<String, Integer, C> swapValues = create("foo", 1, 'c', "bar", 1, 'b', "foo", 3, 'a');

        HashBasedTable.create((Table<String, Integer, ? extends Character>) table);
    Table<String, Integer, C> reordered = create("foo", 3, 'c', "foo", 1, 'a', "bar", 1, 'b');
    Table<String, Integer, C> smaller = create("foo", 1, 'a', "bar", 1, 'b');
    Table<String, Integer, C> swapOuter = create("bar", 1, 'a', "foo", 1, 'b', "bar", 3, 'c');
    Table<String, Integer, C> swapValues = create("foo", 1, 'c', "bar", 1, 'b', "foo", 3, 'a');

    ArrayListMultimap<String, Integer> multimap = ArrayListMultimap.create(original);
    assertEquals(3, multimap.expectedValuesPerKey);
  }

  public void testCreateFromArrayListMultimap() {
    ArrayListMultimap<String, Integer> original = ArrayListMultimap.create(15, 20);
    ArrayListMultimap<String, Integer> multimap = ArrayListMultimap.create(original);

                        keys ->
                            path.create(transform(keys, key -> immutableEntry(key, new Object()))),
                        keys ->
                            path.create(transform(keys, key -> immutableEntry(new Object(), key))),
                        keys -> path.create(transform(keys, key -> immutableEntry(key, key)))))
            .collect(toImmutableList()),