*/
  static final class InvertedMinMaxPriorityQueue<T> extends ForwardingQueue<T> {
    MinMaxPriorityQueue<T> mmHeap;

    public InvertedMinMaxPriorityQueue(Comparator<T> comparator) {
      mmHeap = MinMaxPriorityQueue.orderedBy(comparator).create();
    }

    @Override
    protected Queue<T> delegate() {
      return mmHeap;
    }

    @Override
    public @Nullable T poll() {
      return mmHeap.pollLast();
    }
  }

    this.nodeV = checkNotNull(nodeV);
  }

  /** Returns an {@link EndpointPair} representing the endpoints of a directed edge. */
  public static <N> EndpointPair<N> ordered(N source, N target) {
    return new Ordered<>(source, target);
  }

  /** Returns an {@link EndpointPair} representing the endpoints of an undirected edge. */
  public static <N> EndpointPair<N> unordered(N nodeU, N nodeV) {

            .putEdgeValue(1, 2, "1-2")
            .build();

    assertThat(graph.incidentEdges(2))
        .containsExactly(
            EndpointPair.ordered(2, 1), EndpointPair.ordered(2, 3), EndpointPair.ordered(1, 2))
        .inOrder();
  }

  @Test
  public void immutableValueGraphBuilder_incidentEdgeOrder_stable() {
    ImmutableValueGraph<Integer, String> graph =

    assertThat(graph.nodes()).containsExactly("A", "B");
    assertThat(graph.edges()).containsExactly(EndpointPair.ordered("A", "B"));
  }

  @Test
  public void immutableGraphBuilder_putEdgeFromEndpointPair() {
    ImmutableGraph<String> graph =
        GraphBuilder.directed().<String>immutable().putEdge(EndpointPair.ordered("A", "B")).build();

    assertThat(graph.nodes()).containsExactly("A", "B");

    assertThat(graph.nodes()).containsExactly("A", "B");
    assertThat(graph.edges()).containsExactly(EndpointPair.ordered("A", "B"));
  }

  @Test
  public void immutableGraphBuilder_putEdgeFromEndpointPair() {
    ImmutableGraph<String> graph =
        GraphBuilder.directed().<String>immutable().putEdge(EndpointPair.ordered("A", "B")).build();

    assertThat(graph.nodes()).containsExactly("A", "B");

            .putEdgeValue(1, 2, "1-2")
            .build();

    assertThat(graph.incidentEdges(2))
        .containsExactly(
            EndpointPair.ordered(2, 1), EndpointPair.ordered(2, 3), EndpointPair.ordered(1, 2))
        .inOrder();
  }

  @Test
  public void immutableValueGraphBuilder_incidentEdgeOrder_stable() {
    ImmutableValueGraph<Integer, String> graph =

    assertThat(network.incidentNodes(10)).isEqualTo(EndpointPair.ordered("A", "B"));
  }

  @Test
  public void immutableNetworkBuilder_putEdgeFromEndpointPair() {
    ImmutableNetwork<String, Integer> network =
        NetworkBuilder.directed()
            .<String, Integer>immutable()
            .addEdge(EndpointPair.ordered("A", "B"), 10)
            .build();

  public void testForEachKnownOrder() {
    List<E> elements = new ArrayList<>();
    collection.forEach(elements::add);
    List<E> expected = Helpers.copyToList(getOrderedElements());
    assertEquals("Different ordered iteration", expected, elements);
  }

@GwtCompatible
@ElementTypesAreNonnullByDefault
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.
   */
  Comparator<? super T> comparator();

  /**
   * Returns an iterator over elements of type {@code T}. The elements are returned in nondecreasing

@GwtCompatible
@ElementTypesAreNonnullByDefault
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.
   */
  Comparator<? super T> comparator();

  /**
   * Returns an iterator over elements of type {@code T}. The elements are returned in nondecreasing