@Override
      public Queue<Integer> create(Comparator<Integer> comparator) {
        return new InvertedMinMaxPriorityQueue<>(comparator);
      }
    };

    public abstract Queue<Integer> create(Comparator<Integer> comparator);
  }

  /**
   * Does a CPU intensive operation on Integer and returns a BigInteger Used to implement an
   * ordering that spends a lot of cpu.
   */

      @Override
      public Queue<Integer> create(Comparator<Integer> comparator) {
        return new InvertedMinMaxPriorityQueue<>(comparator);
      }
    };

    public abstract Queue<Integer> create(Comparator<Integer> comparator);
  }

  /**
   * Does a CPU intensive operation on Integer and returns a BigInteger Used to implement an
   * ordering that spends a lot of cpu.
   */

    private final int endPort;
    private final Lock lock = new ReentrantLock();
    private PortDetector portDetector = new DefaultPortDetector();
    private final List<Integer> allocated = new ArrayList<Integer>();
    private Map<String, Integer> allocatedPortsId = new HashMap<>();
    private int current;

    public ReservedPortRange(int startPort, int endPort) {
        this.startPort = startPort;

      Arrays.sort(dataset);
      return singleQuantileFromSorted(index, scale, dataset);
    }

    @Override
    Map<Integer, Double> multipleQuantiles(
        Collection<Integer> indexes, int scale, double[] dataset) {
      Arrays.sort(dataset);
      ImmutableMap.Builder<Integer, Double> builder = ImmutableMap.builder();
      for (int index : indexes) {

  }

  private static void runConcurrentlyMutatedTest(
      Collection<Integer> initialContents,
      Iterable<ListFrobber> actionsToPerformConcurrently,
      WrapWithIterable wrap) {
    ConcurrentlyMutatedList<Integer> concurrentlyMutatedList =
        newConcurrentlyMutatedList(initialContents, actionsToPerformConcurrently);

    Iterable<Integer> iterableToCopy =
        wrap == WrapWithIterable.WRAP

            "type" : "keyword"
          },
          "intervalTime" : {
            "type" : "integer"
          },
          "maxAccessCount" : {
            "type" : "long"
          },
          "name" : {
            "type" : "keyword"
          },
          "numOfThread" : {
            "type" : "integer"
          },
          "permissions" : {
            "type" : "keyword"
          },

@RunWith(JUnit4.class)
@NullUnmarked
public final class EndpointPairTest {
  private static final Integer N0 = 0;
  private static final Integer N1 = 1;
  private static final Integer N2 = 2;
  private static final Integer N3 = 3;
  private static final Integer N4 = 4;
  private static final String E12 = "1-2";
  private static final String E12_A = "1-2a";
  private static final String E21 = "2-1";

@RunWith(JUnit4.class)
@NullUnmarked
public final class EndpointPairTest {
  private static final Integer N0 = 0;
  private static final Integer N1 = 1;
  private static final Integer N2 = 2;
  private static final Integer N3 = 3;
  private static final Integer N4 = 4;
  private static final String E12 = "1-2";
  private static final String E12_A = "1-2a";
  private static final String E21 = "2-1";

    putEdge(N2, N1);
    Set<Integer> n1AdjacentNodes = graph.adjacentNodes(N1);
    Set<Integer> n2AdjacentNodes = graph.adjacentNodes(N2);
    Set<Integer> n1Predecessors = graph.predecessors(N1);
    Set<Integer> n2Predecessors = graph.predecessors(N2);
    Set<Integer> n1Successors = graph.successors(N1);
    Set<Integer> n2Successors = graph.successors(N2);
    Set<EndpointPair<Integer>> n1IncidentEdges = graph.incidentEdges(N1);

@NullUnmarked
public final class Collections2FilterArrayListTest
    extends AbstractFilteredCollectionTest<Collection<Integer>> {
  @Override
  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);
  }