@Override
    protected List<String> create(String[] elements) {
      ImmutableSortedMap.Builder<String, Integer> builder = ImmutableSortedMap.naturalOrder();
      for (int i = 0; i < elements.length; i++) {
        builder.put(elements[i], i);
      }
      return builder.build().keySet().asList();
    }

    @Override

    }

    @SuppressWarnings("unchecked")
    @Override
    public BiMap<V, K> create(Object... elements) {
      Entry<?, ?>[] entries = new Entry<?, ?>[elements.length];
      for (int i = 0; i < elements.length; i++) {
        entries[i] = reverse((Entry<K, V>) elements[i]);
      }
      return generator.create((Object[]) entries).inverse();
    }

    @SuppressWarnings("unchecked")

    final BlockingQueue<Object> q;
    final int elements;
    final CountDownLatch beganProducing = new CountDownLatch(1);
    final CountDownLatch doneProducing = new CountDownLatch(1);

    Producer(BlockingQueue<Object> q, int elements) {
      this.q = q;
      this.elements = elements;
    }

    @Override
    public @Nullable Void call() throws InterruptedException {

 * both {@link Collection} and {@link Map}; since there isn't an established collective noun that
 * encompasses both of these, 'container' is used.
 *
 * @author George van den Driessche
 */
@GwtCompatible
@NullMarked
public interface TestContainerGenerator<T, E extends @Nullable Object> {
  /** Returns the sample elements that this generate populates its container with. */

    }

    def "closes implicit <p> element at start of block element"() {
        expect:
        parse(source) == transformed

        where:
        source              | transformed
        "text<p>para 2</p>" | "<p>text</p><p>para 2</p>"
        "text<h2>text</h2>" | "<p>text</p><h2>text</h2>"
    }

    def "does not add implicit <p> element for elements with inline content"() {
        expect:

/**
 * An {@code Iterable} whose elements are sorted relative to a {@code Comparator}, typically
 * provided at creation time.
 *
 * @author Louis Wasserman
 */
@GwtCompatible
interface SortedIterable<T extends @Nullable Object> extends Iterable<T> {
  /**
   * Returns the {@code Comparator} by which the elements of this iterable are ordered, or {@code
   * Ordering.natural()} if the elements are ordered by their natural ordering.
   */

/**
 * An {@code Iterable} whose elements are sorted relative to a {@code Comparator}, typically
 * provided at creation time.
 *
 * @author Louis Wasserman
 */
@GwtCompatible
interface SortedIterable<T extends @Nullable Object> extends Iterable<T> {
  /**
   * Returns the {@code Comparator} by which the elements of this iterable are ordered, or {@code
   * Ordering.natural()} if the elements are ordered by their natural ordering.
   */

    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 false;
              }
              List<TypeWithDuplicates> elements1 = ImmutableList.copyOf(ms1.elementSet());
              List<TypeWithDuplicates> elements2 = ImmutableList.copyOf(ms2.elementSet());
              for (int i = 0; i < ms1.elementSet().size(); i++) {
                if (!elements1.get(i).fullEquals(elements2.get(i))) {
                  return false;
                }
              }