def test_decoding2(self):
     # Example from "An Optimal Algorithm for Prufer Codes".
     sequence = [2, 4, 0, 1, 3, 3]
     tree = nx.from_prufer_sequence(sequence)
     assert_nodes_equal(list(tree), list(range(8)))
     edges = [(0, 1), (0, 4), (1, 3), (2, 4), (2, 5), (3, 6), (3, 7)]
     assert_edges_equal(list(tree.edges()), edges)

    def test_graph(self):
        g = nx.cycle_graph(10)
        G = nx.Graph()
        G.add_nodes_from(g)
        G.add_weighted_edges_from((u, v, u) for u, v in g.edges())

        # Dict of dicts
        dod = to_dict_of_dicts(G)
        GG = from_dict_of_dicts(dod, create_using=nx.Graph())
        assert_nodes_equal(sorted(G.nodes()), sorted(GG.nodes()))
        assert_edges_equal(sorted(G.edges()), sorted(GG.edges()))
        GW = to_networkx_graph(dod, create_using=nx.Graph())
        assert_nodes_equal(sorted(G.nodes()), sorted(GW.nodes()))
        assert_edges_equal(sorted(G.edges()), sorted(GW.edges()))
        GI = nx.Graph(dod)
        assert_equal(sorted(G.nodes()), sorted(GI.nodes()))
        assert_equal(sorted(G.edges()), sorted(GI.edges()))

        # Dict of lists
        dol = to_dict_of_lists(G)
        GG = from_dict_of_lists(dol, create_using=nx.Graph())
        # dict of lists throws away edge data so set it to none
        enone = [(u, v, {}) for (u, v, d) in G.edges(data=True)]
        assert_nodes_equal(sorted(G.nodes()), sorted(GG.nodes()))
        assert_edges_equal(enone, sorted(GG.edges(data=True)))
        GW = to_networkx_graph(dol, create_using=nx.Graph())
        assert_nodes_equal(sorted(G.nodes()), sorted(GW.nodes()))
        assert_edges_equal(enone, sorted(GW.edges(data=True)))
        GI = nx.Graph(dol)
        assert_nodes_equal(sorted(G.nodes()), sorted(GI.nodes()))
        assert_edges_equal(enone, sorted(GI.edges(data=True)))

 def test_path_projected_graph(self):
     G=nx.path_graph(4)
     P=bipartite.projected_graph(G, [1, 3])
     assert_nodes_equal(list(P), [1, 3])
     assert_edges_equal(list(P.edges()), [(1, 3)])
     P=bipartite.projected_graph(G, [0, 2])
     assert_nodes_equal(list(P), [0, 2])
     assert_edges_equal(list(P.edges()), [(0, 2)])

 def test_multiline_adjlist_delimiter(self):
     fh = io.BytesIO()
     G = nx.path_graph(3)
     nx.write_multiline_adjlist(G, fh, delimiter=':')
     fh.seek(0)
     H = nx.read_multiline_adjlist(fh, nodetype=int, delimiter=':')
     assert_nodes_equal(list(H), list(G))
     assert_edges_equal(list(H.edges()), list(G.edges()))

 def test_decoding(self):
     """Tests for decoding a tree from a Prüfer sequence."""
     # Example from Wikipedia.
     sequence = [3, 3, 3, 4]
     tree = nx.from_prufer_sequence(sequence)
     assert_nodes_equal(list(tree), list(range(6)))
     edges = [(0, 3), (1, 3), (2, 3), (3, 4), (4, 5)]
     assert_edges_equal(list(tree.edges()), edges)

 def test_reverse_hashable(self):
     class Foo(object):
         pass
     x = Foo()
     y = Foo()
     G = nx.DiGraph()
     G.add_edge(x, y)
     assert_nodes_equal(G.nodes(), G.reverse().nodes())
     assert_equal([(y, x)], list(G.reverse().edges()))

    def test_complete_2_partite_graph(self):
        """Tests that the complete 2-partite graph is the complete bipartite
        graph.

        """
        G = nx.complete_multipartite_graph(2, 3)
        H = nx.complete_bipartite_graph(2, 3)
        assert_nodes_equal(G, H)
        assert_edges_equal(G.edges(), H.edges())

    def assert_equal(self, G, data=False):
        (fd, fname) = tempfile.mkstemp()
        nx.write_yaml(G, fname)
        Gin = nx.read_yaml(fname)

        assert_nodes_equal(list(G), list(Gin))
        assert_edges_equal(G.edges(data=data), Gin.edges(data=data))

        os.close(fd)
        os.unlink(fname)

 def test_path_weighted_projected_graph(self):
     G=nx.path_graph(4)
     P=bipartite.weighted_projected_graph(G,[1,3])
     assert_nodes_equal(list(P),[1,3])
     assert_edges_equal(list(P.edges()),[(1,3)])
     P[1][3]['weight']=1
     P=bipartite.weighted_projected_graph(G,[0,2])
     assert_nodes_equal(list(P),[0,2])
     assert_edges_equal(list(P.edges()),[(0,2)])
     P[0][2]['weight']=1

    def test_single(self):
        """Tests that joining just one tree yields a tree with one more
        node.

        """
        T = nx.empty_graph(1)
        actual = nx.join([(T, 0)])
        expected = nx.path_graph(2)
        assert_nodes_equal(list(expected), list(actual))
        assert_edges_equal(list(expected.edges()), list(actual.edges()))

 def test_path_collaboration_projected_graph(self):
     G=nx.path_graph(4)
     P=bipartite.collaboration_weighted_projected_graph(G,[1,3])
     assert_nodes_equal(P.nodes(),[1,3])
     assert_edges_equal(P.edges(),[(1,3)])
     P[1][3]['weight']=1
     P=bipartite.collaboration_weighted_projected_graph(G,[0,2])
     assert_nodes_equal(P.nodes(),[0,2])
     assert_edges_equal(P.edges(),[(0,2)])
     P[0][2]['weight']=1

 def test_multiline_adjlist_integers(self):
     (fd, fname) = tempfile.mkstemp()
     G = nx.convert_node_labels_to_integers(self.G)
     nx.write_multiline_adjlist(G, fname)
     H = nx.read_multiline_adjlist(fname, nodetype=int)
     H2 = nx.read_multiline_adjlist(fname, nodetype=int)
     assert_nodes_equal(list(H), list(G))
     assert_edges_equal(list(H.edges()), list(G.edges()))
     os.close(fd)
     os.unlink(fname)

 def test_attributes(self):
     G = nx.Graph()
     G.add_edge(1, 2, weight=1, color='red', distance=7)
     G.add_edge(2, 3, weight=1, color='green', distance=2)
     G.add_edge(1, 3, weight=10, color='blue', distance=1)
     G.graph['foo'] = 'bar'
     T = nx.minimum_spanning_tree(G, algorithm=self.algo)
     assert_equal(T.graph, G.graph)
     assert_nodes_equal(T, G)
     for u, v in T.edges():
         assert_equal(T.adj[u][v], G.adj[u][v])

 def test_edgelist_multigraph(self):
     G=self.MG
     (fd,fname)=tempfile.mkstemp()
     bipartite.write_edgelist(G,fname) 
     H=bipartite.read_edgelist(fname,nodetype=int,create_using=nx.MultiGraph())
     H2=bipartite.read_edgelist(fname,nodetype=int,create_using=nx.MultiGraph())
     assert_not_equal(H,H2) # they should be different graphs
     assert_nodes_equal(H.nodes(),G.nodes())
     assert_edges_equal(H.edges(),G.edges())
     os.close(fd)
     os.unlink(fname)

 def test_path_weighted_projected_directed_graph(self):
     G = nx.DiGraph()
     G.add_path(list(range(4)))
     P = bipartite.weighted_projected_graph(G, [1, 3])
     assert_nodes_equal(P.nodes(), [1, 3])
     assert_edges_equal(P.edges(), [(1, 3)])
     P[1][3]["weight"] = 1
     P = bipartite.weighted_projected_graph(G, [0, 2])
     assert_nodes_equal(P.nodes(), [0, 2])
     assert_edges_equal(P.edges(), [(0, 2)])
     P[0][2]["weight"] = 1

 def test_directed_path_collaboration_projected_graph(self):
     G=nx.DiGraph()
     G.add_path(list(range(4)))
     P=bipartite.collaboration_weighted_projected_graph(G,[1,3])
     assert_nodes_equal(list(P),[1,3])
     assert_edges_equal(list(P.edges()),[(1,3)])
     P[1][3]['weight']=1
     P=bipartite.collaboration_weighted_projected_graph(G,[0,2])
     assert_nodes_equal(list(P),[0,2])
     assert_edges_equal(list(P.edges()),[(0,2)])
     P[0][2]['weight']=1

 def test_edgelist_integers(self):
     G = nx.convert_node_labels_to_integers(self.G)
     (fd, fname) = tempfile.mkstemp()
     nx.write_edgelist(G, fname)
     H = nx.read_edgelist(fname, nodetype=int)
     # isolated nodes are not written in edgelist
     G.remove_nodes_from(list(nx.isolates(G)))
     assert_nodes_equal(list(H), list(G))
     assert_edges_equal(list(H.edges()), list(G.edges()))
     os.close(fd)
     os.unlink(fname)

 def test_adjlist_digraph(self):
     G = self.DG
     (fd, fname) = tempfile.mkstemp()
     nx.write_adjlist(G, fname)
     H = nx.read_adjlist(fname, create_using=nx.DiGraph())
     H2 = nx.read_adjlist(fname, create_using=nx.DiGraph())
     assert_not_equal(H, H2)  # they should be different graphs
     assert_nodes_equal(list(H), list(G))
     assert_edges_equal(list(H.edges()), list(G.edges()))
     os.close(fd)
     os.unlink(fname)

 def test_multiline_adjlist_graph(self):
     G = self.G
     (fd, fname) = tempfile.mkstemp()
     nx.write_multiline_adjlist(G, fname)
     H = nx.read_multiline_adjlist(fname)
     H2 = nx.read_multiline_adjlist(fname)
     assert_not_equal(H, H2)  # they should be different graphs
     assert_nodes_equal(list(H), list(G))
     assert_edges_equal(list(H.edges()), list(G.edges()))
     os.close(fd)
     os.unlink(fname)

 def test_path_projected_properties_graph(self):
     G=nx.path_graph(4)
     G.add_node(1,name='one')
     G.add_node(2,name='two')
     P=bipartite.projected_graph(G,[1,3])
     assert_nodes_equal(list(P),[1,3])
     assert_edges_equal(list(P.edges()),[(1,3)])
     assert_equal(P.node[1]['name'],G.node[1]['name'])
     P=bipartite.projected_graph(G,[0,2])
     assert_nodes_equal(list(P),[0,2])
     assert_edges_equal(list(P.edges()),[(0,2)])
     assert_equal(P.node[2]['name'],G.node[2]['name'])