return new Strings();
  }

  @Override
  public Collection<String> create(Object... elements) {
    String[] array = new String[elements.length];
    int i = 0;
    for (Object e : elements) {
      array[i++] = (String) e;
    }
    return create(array);
  }

  protected abstract Collection<String> create(String[] elements);

  @Override
  public String[] createArray(int length) {
    return new String[length];

    return new Strings();
  }

  @Override
  public Queue<String> create(Object... elements) {
    String[] array = new String[elements.length];
    int i = 0;
    for (Object e : elements) {
      array[i++] = (String) e;
    }
    return create(array);
  }

  protected abstract Queue<String> create(String[] elements);

  @Override
  public String[] createArray(int length) {
    return new String[length];

    return new Ints();
  }

  @Override
  public Set<Integer> create(Object... elements) {
    Integer[] array = new Integer[elements.length];
    int i = 0;
    for (Object e : elements) {
      array[i++] = (Integer) e;
    }
    return create(array);
  }

  protected abstract Set<Integer> create(Integer[] elements);

  @Override
  public Integer[] createArray(int length) {
    return new Integer[length];

    Iterator<E> iterator = collection.iterator();
    Object element = iterator.next();
    // If it's an Entry, it may become invalid once it's removed from the Map. Copy it.
    if (element instanceof Entry) {
      Entry<?, ?> entry = (Entry<?, ?>) element;
      element = mapEntry(entry.getKey(), entry.getValue());
    }
    assertTrue(collection.contains(element)); // sanity check
    iterator.remove();

        .onClose(streamB::close);
  }

  /**
   * Invokes {@code consumer} once for each pair of <i>corresponding</i> elements in {@code streamA}
   * and {@code streamB}. If one stream is longer than the other, the extra elements are silently
   * ignored. Elements passed to the consumer are guaranteed to come from the same position in their
   * respective source streams. For example:
   *
   * {@snippet :

      return standardAddAll(collection);
    }

    @Override
    public boolean add(T element) {
      return standardAdd(element);
    }

    @Override
    public void clear() {
      standardClear();
    }

    @Override
    public int count(Object element) {
      return standardCount(element);
    }

    @Override
    public boolean contains(Object object) {

              public Collection<String> create(String[] elements) {
                // TODO: MinimalCollection should perhaps throw
                for (Object element : elements) {
                  if (element == null) {
                    throw new NullPointerException();
                  }
                }
                return MinimalCollection.of(elements);
              }
            })

   *       href="https://github.com/google/guava/wiki/GraphsExplained#graph-elements-nodes-and-edges">
   *       graph elements</a> for details)
   * </ul>
   *
   * @throws IllegalArgumentException if {@code node} is not an element of this graph
   */
  Iterable<? extends N> successors(N node);

import org.jspecify.annotations.Nullable;

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

    return Sets.newTreeSet(contents);
  }

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