import org.checkerframework.checker.nullness.qual.Nullable;

/**
 * Creates queues, containing sample elements, to be tested.
 *
 * @author Jared Levy
 */
@GwtCompatible
@ElementTypesAreNonnullByDefault
public interface TestQueueGenerator<E extends @Nullable Object> extends TestCollectionGenerator<E> {
  @Override
  Queue<E> create(Object... elements);

import org.checkerframework.checker.nullness.qual.Nullable;

/**
 * Creates sets, containing sample elements, to be tested.
 *
 * @author Kevin Bourrillion
 */
@GwtCompatible
@ElementTypesAreNonnullByDefault
public interface TestListGenerator<E extends @Nullable Object> extends TestCollectionGenerator<E> {
  @Override
  List<E> create(Object... elements);

  Collection<Integer> createUnfiltered(Iterable<Integer> contents) {
    return Lists.newArrayList(contents);
  }

  @Override
  Collection<Integer> filter(Collection<Integer> elements, Predicate<? super Integer> predicate) {
    return Collections2.filter(elements, predicate);
  }

  @Override
  Set<Integer> createUnfiltered(Iterable<Integer> contents) {
    return newHashSet(contents);
  }

  @Override
  Set<Integer> filter(Set<Integer> elements, Predicate<? super Integer> predicate) {
    return Sets.filter(elements, predicate);
  }

/**
 * Creates multisets, containing sample elements, to be tested.
 *
 * @author Jared Levy
 */
@GwtCompatible
@ElementTypesAreNonnullByDefault
public interface TestMultisetGenerator<E extends @Nullable Object>
    extends TestCollectionGenerator<E> {
  @Override
  Multiset<E> create(Object... elements);

                new TestStringSetGenerator() {
                  @Override
                  protected Set<String> create(String[] elements) {
                    return new StandardImplForwardingNavigableSet<>(
                        new SafeTreeSet<String>(asList(elements)));
                  }

                  @Override
                  public List<String> order(List<String> insertionOrder) {

  Iterable<Integer> createUnfiltered(Iterable<Integer> contents) {
    return Lists.newArrayList(contents);
  }

  @Override
  Iterable<Integer> filter(Iterable<Integer> elements, Predicate<? super Integer> predicate) {
    return Iterables.filter(elements, predicate);
  }

  public static <E> TestSetGenerator<E> newInstance(TestSetGenerator<E> delegate) {
    return new ReserializingTestSetGenerator<>(delegate);
  }

  @Override
  public Set<E> create(Object... elements) {
    return (Set<E>) super.create(elements);
  }

  private static final class PickyIterable<E> implements Iterable<E> {
    final List<E> elements;
    int modCount = 0;

    PickyIterable(E... elements) {
      this.elements = new ArrayList<E>(asList(elements));
    }

    @Override
    public Iterator<E> iterator() {
      return new PickyIterator();
    }

   * <i>should</i> hold {@code expectedSize} elements without rebuilding internal data structures.
   *
   * @param expectedSize the number of elements you expect to add to the returned set
   * @return a new, empty {@code CompactLinkedHashMap} with enough capacity to hold {@code
   *     expectedSize} elements without resizing
   * @throws IllegalArgumentException if {@code expectedSize} is negative
   */