public static <E extends Comparable> PriorityQueue<E> newPriorityQueue() {
    return new PriorityQueue<>();
  }

  /**
   * Creates a {@code PriorityQueue} containing the given elements.
   *
   * <p><b>Note:</b> If the specified iterable is a {@code SortedSet} or a {@code PriorityQueue},
   * this priority queue will be ordered according to the same ordering.
   *

import com.google.common.base.Function;
import java.math.BigInteger;
import java.util.Comparator;
import java.util.PriorityQueue;
import java.util.Queue;
import java.util.Random;
import org.checkerframework.checker.nullness.qual.Nullable;

/**
 * Benchmarks to compare performance of MinMaxPriorityQueue and PriorityQueue.
 *
 * @author Sverre Sundsdal
 */
public class MinMaxPriorityQueueBenchmark {

import java.util.NoSuchElementException;
import java.util.PriorityQueue;
import java.util.Queue;
import java.util.SortedSet;
import java.util.concurrent.BlockingQueue;
import java.util.concurrent.TimeUnit;
import org.checkerframework.checker.nullness.qual.Nullable;

/**
 * An unbounded {@linkplain BlockingQueue blocking queue} that uses the same ordering rules as class

  public static <E extends Comparable> PriorityQueue<E> newPriorityQueue() {
    return new PriorityQueue<>();
  }

  /**
   * Creates a {@code PriorityQueue} containing the given elements.
   *
   * <p><b>Note:</b> If the specified iterable is a {@code SortedSet} or a {@code PriorityQueue},
   * this priority queue will be ordered according to the same ordering.
   *

            new TestStringQueueGenerator() {
              @Override
              public Queue<String> create(String[] elements) {
                return new PriorityQueue<>(MinimalCollection.of(elements));
              }
            })
        .named("PriorityQueue")
        .withFeatures(CollectionFeature.GENERAL_PURPOSE, CollectionSize.ANY)
        .suppressing(suppressForPriorityQueue())
        .createTestSuite();
  }

 * limitations under the License.
 */

import java.io.IOException;
import java.util.ArrayList;
import java.util.Comparator;
import java.util.List;
import java.util.PriorityQueue;

import org.apache.lucene.analysis.Tokenizer;
import org.apache.lucene.analysis.synonym.SynonymMap;
import org.apache.lucene.analysis.tokenattributes.CharTermAttribute;

 * as the traditional heap data structure used in {@link PriorityQueue}.
 *
 * <p>This class is not thread-safe, and does not accept null elements.
 *
 * <p><i>Performance notes:</i>
 *
 * <ul>
 *   <li>If you only access one end of the queue, and do use a maximum size, this class will perform
 *       significantly worse than a {@code PriorityQueue} with manual eviction above the maximum

 * as the traditional heap data structure used in {@link PriorityQueue}.
 *
 * <p>This class is not thread-safe, and does not accept null elements.
 *
 * <p><i>Performance notes:</i>
 *
 * <ul>
 *   <li>If you only access one end of the queue, and do use a maximum size, this class will perform
 *       significantly worse than a {@code PriorityQueue} with manual eviction above the maximum

    }
  }

  public void testCorrectOrdering_randomAccess() {
    long seed = new Random().nextLong();
    Random random = new Random(seed);
    PriorityQueue<Integer> control = new PriorityQueue<>();
    MinMaxPriorityQueue<Integer> q = MinMaxPriorityQueue.create();
    for (int i = 0; i < 73; i++) { // 73 is a childless uncle case.
      Integer element = random.nextInt();

    assertTrue(ArbitraryInstances.get(PriorityQueue.class).isEmpty());
    assertTrue(ArbitraryInstances.get(BitSet.class).isEmpty());
    assertTrue(ArbitraryInstances.get(TreeSet.class).isEmpty());
    assertTrue(ArbitraryInstances.get(TreeMap.class).isEmpty());
    assertFreshInstanceReturned(
        LinkedList.class,
        Deque.class,
        Queue.class,
        PriorityQueue.class,
        BitSet.class,