Shinsuke Sugaya <******@****.***> 1472420222 +0900

   * endpoints}) if one is not already present.
   *
   * <p>If this graph is directed, {@code endpoints} must be ordered and the added edge will be
   * directed; if it is undirected, the added edge will be undirected.
   *
   * <p>If this graph is directed, {@code endpoints} must be ordered.
   *
   * <p>If either or both endpoints are not already present in this graph, this method will silently

    assertThrows(
        UnsupportedOperationException.class, () -> edges.add(EndpointPair.ordered(N1, N2)));
  }

  @Test
  public void endpointPair_undirected_contains() {
    MutableGraph<Integer> undirectedGraph = GraphBuilder.undirected().allowsSelfLoops(true).build();
    undirectedGraph.putEdge(N1, N1);
    undirectedGraph.putEdge(N1, N2);
    Set<EndpointPair<Integer>> edges = undirectedGraph.edges();

    assertThrows(
        UnsupportedOperationException.class, () -> edges.add(EndpointPair.ordered(N1, N2)));
  }

  @Test
  public void endpointPair_undirected_contains() {
    MutableGraph<Integer> undirectedGraph = GraphBuilder.undirected().allowsSelfLoops(true).build();
    undirectedGraph.putEdge(N1, N1);
    undirectedGraph.putEdge(N1, N2);
    Set<EndpointPair<Integer>> edges = undirectedGraph.edges();

  Network<Integer, String> undirectedNetwork;

  @Before
  public void init() {
    MutableGraph<Integer> mutableDirectedGraph =
        GraphBuilder.directed().allowsSelfLoops(true).build();
    MutableGraph<Integer> mutableUndirectedGraph =
        GraphBuilder.undirected().allowsSelfLoops(true).build();
    graphsToTest = ImmutableList.of(mutableDirectedGraph, mutableUndirectedGraph);
    directedGraph = mutableDirectedGraph;

   * that edge to {@code value} (overwriting the existing value, if any).
   *
   * <p>If the graph is directed, the resultant edge will be directed; otherwise, it will be
   * undirected.
   *
   * <p>If this graph is directed, {@code endpoints} must be ordered.
   *
   * <p>Values do not have to be unique. However, values must be non-null.
   *

import com.google.common.collect.ImmutableList;
import com.google.errorprone.annotations.CanIgnoreReturnValue;

/**
 * Standard implementation of {@link MutableNetwork} that supports both directed and undirected
 * graphs. Instances of this class should be constructed with {@link NetworkBuilder}.
 *
 * <p>Time complexities for mutation methods are all O(1) except for {@code removeNode(N node)},

   *     false, creates an instance for graphs whose edges are each undirected.
   */
  AbstractGraphBuilder(boolean directed) {
    this.directed = directed;
  }

   * }</pre>
   *
   * @param tree {@link SuccessorsFunction} representing a directed acyclic graph that has at most
   *     one path between any two nodes
   */
  public static <N> Traverser<N> forTree(SuccessorsFunction<N> tree) {
    if (tree instanceof BaseGraph) {
      checkArgument(((BaseGraph<?>) tree).isDirected(), "Undirected graphs can never be trees.");
    }
    if (tree instanceof Network) {

    ImmutableValueGraph<String, Integer> emptyGraph =
        ValueGraphBuilder.directed()
            .allowsSelfLoops(true)
            .nodeOrder(ElementOrder.<String>natural())
            .<String, Integer>immutable()
            .build();

    assertThat(emptyGraph.isDirected()).isTrue();
    assertThat(emptyGraph.allowsSelfLoops()).isTrue();