Home | History | Annotate | Download | only in tests
      1 #!/usr/bin/env python
      2 from nose.tools import *
      3 from networkx import *
      4 from networkx.convert import *
      5 from networkx.algorithms.operators import *
      6 from networkx.generators.classic import barbell_graph,cycle_graph
      7 from networkx.testing import *
      8 
      9 class TestRelabel():
     10     def test_convert_node_labels_to_integers(self):
     11         # test that empty graph converts fine for all options
     12         G=empty_graph()
     13         H=convert_node_labels_to_integers(G,100)
     14         assert_equal(H.name, '(empty_graph(0))_with_int_labels')
     15         assert_equal(H.nodes(), [])
     16         assert_equal(H.edges(), [])
     17 
     18         for opt in ["default", "sorted", "increasing degree",
     19                     "decreasing degree"]:
     20             G=empty_graph()
     21             H=convert_node_labels_to_integers(G,100, ordering=opt)
     22             assert_equal(H.name, '(empty_graph(0))_with_int_labels')
     23             assert_equal(H.nodes(), [])
     24             assert_equal(H.edges(), [])
     25 
     26         G=empty_graph()
     27         G.add_edges_from([('A','B'),('A','C'),('B','C'),('C','D')])
     28         G.name="paw"
     29         H=convert_node_labels_to_integers(G)
     30         degH=H.degree().values()
     31         degG=G.degree().values()
     32         assert_equal(sorted(degH), sorted(degG))
     33 
     34         H=convert_node_labels_to_integers(G,1000)
     35         degH=H.degree().values()
     36         degG=G.degree().values()
     37         assert_equal(sorted(degH), sorted(degG))
     38         assert_equal(H.nodes(), [1000, 1001, 1002, 1003])
     39 
     40         H=convert_node_labels_to_integers(G,ordering="increasing degree")
     41         degH=H.degree().values()
     42         degG=G.degree().values()
     43         assert_equal(sorted(degH), sorted(degG))
     44         assert_equal(degree(H,0), 1)
     45         assert_equal(degree(H,1), 2)
     46         assert_equal(degree(H,2), 2)
     47         assert_equal(degree(H,3), 3)
     48 
     49         H=convert_node_labels_to_integers(G,ordering="decreasing degree")
     50         degH=H.degree().values()
     51         degG=G.degree().values()
     52         assert_equal(sorted(degH), sorted(degG))
     53         assert_equal(degree(H,0), 3)
     54         assert_equal(degree(H,1), 2)
     55         assert_equal(degree(H,2), 2)
     56         assert_equal(degree(H,3), 1)
     57 
     58         H=convert_node_labels_to_integers(G,ordering="increasing degree",
     59                                           label_attribute='label')
     60         degH=H.degree().values()
     61         degG=G.degree().values()
     62         assert_equal(sorted(degH), sorted(degG))
     63         assert_equal(degree(H,0), 1)
     64         assert_equal(degree(H,1), 2)
     65         assert_equal(degree(H,2), 2)
     66         assert_equal(degree(H,3), 3)
     67 
     68         # check mapping
     69         assert_equal(H.node[3]['label'],'C')
     70         assert_equal(H.node[0]['label'],'D')
     71         assert_true(H.node[1]['label']=='A' or H.node[2]['label']=='A')
     72         assert_true(H.node[1]['label']=='B' or H.node[2]['label']=='B')
     73 
     74     def test_convert_to_integers2(self):
     75         G=empty_graph()
     76         G.add_edges_from([('C','D'),('A','B'),('A','C'),('B','C')])
     77         G.name="paw"
     78         H=convert_node_labels_to_integers(G,ordering="sorted")
     79         degH=H.degree().values()
     80         degG=G.degree().values()
     81         assert_equal(sorted(degH), sorted(degG))
     82 
     83         H=convert_node_labels_to_integers(G,ordering="sorted",
     84                                           label_attribute='label')
     85         assert_equal(H.node[0]['label'],'A')
     86         assert_equal(H.node[1]['label'],'B')
     87         assert_equal(H.node[2]['label'],'C')
     88         assert_equal(H.node[3]['label'],'D')
     89 
     90     @raises(nx.NetworkXError)
     91     def test_convert_to_integers_raise(self):
     92         G = nx.Graph()
     93         H=convert_node_labels_to_integers(G,ordering="increasing age")
     94 
     95 
     96     def test_relabel_nodes_copy(self):
     97         G=empty_graph()
     98         G.add_edges_from([('A','B'),('A','C'),('B','C'),('C','D')])
     99         mapping={'A':'aardvark','B':'bear','C':'cat','D':'dog'}
    100         H=relabel_nodes(G,mapping)
    101         assert_equal(sorted(H.nodes()), ['aardvark', 'bear', 'cat', 'dog'])
    102 
    103     def test_relabel_nodes_function(self):
    104         G=empty_graph()
    105         G.add_edges_from([('A','B'),('A','C'),('B','C'),('C','D')])
    106         # function mapping no longer encouraged but works
    107         def mapping(n):
    108             return ord(n)
    109         H=relabel_nodes(G,mapping)
    110         assert_equal(sorted(H.nodes()), [65, 66, 67, 68])
    111 
    112     def test_relabel_nodes_graph(self):
    113         G=Graph([('A','B'),('A','C'),('B','C'),('C','D')])
    114         mapping={'A':'aardvark','B':'bear','C':'cat','D':'dog'}
    115         H=relabel_nodes(G,mapping)
    116         assert_equal(sorted(H.nodes()), ['aardvark', 'bear', 'cat', 'dog'])
    117 
    118     def test_relabel_nodes_digraph(self):
    119         G=DiGraph([('A','B'),('A','C'),('B','C'),('C','D')])
    120         mapping={'A':'aardvark','B':'bear','C':'cat','D':'dog'}
    121         H=relabel_nodes(G,mapping,copy=False)
    122         assert_equal(sorted(H.nodes()), ['aardvark', 'bear', 'cat', 'dog'])
    123 
    124     def test_relabel_nodes_multigraph(self):
    125         G=MultiGraph([('a','b'),('a','b')])
    126         mapping={'a':'aardvark','b':'bear'}
    127         G=relabel_nodes(G,mapping,copy=False)
    128         assert_equal(sorted(G.nodes()), ['aardvark', 'bear'])
    129         assert_edges_equal(sorted(G.edges()),
    130                            [('aardvark', 'bear'), ('aardvark', 'bear')])
    131 
    132     def test_relabel_nodes_multidigraph(self):
    133         G=MultiDiGraph([('a','b'),('a','b')])
    134         mapping={'a':'aardvark','b':'bear'}
    135         G=relabel_nodes(G,mapping,copy=False)
    136         assert_equal(sorted(G.nodes()), ['aardvark', 'bear'])
    137         assert_equal(sorted(G.edges()),
    138                      [('aardvark', 'bear'), ('aardvark', 'bear')])
    139 
    140     @raises(KeyError)
    141     def test_relabel_nodes_missing(self):
    142         G=Graph([('A','B'),('A','C'),('B','C'),('C','D')])
    143         mapping={0:'aardvark'}
    144         G=relabel_nodes(G,mapping,copy=False)
    145 
    146 
    147     def test_relabel_toposort(self):
    148         K5=nx.complete_graph(4)
    149         G=nx.complete_graph(4)
    150         G=nx.relabel_nodes(G,dict( [(i,i+1) for i in range(4)]),copy=False)
    151         nx.is_isomorphic(K5,G)
    152         G=nx.complete_graph(4)
    153         G=nx.relabel_nodes(G,dict( [(i,i-1) for i in range(4)]),copy=False)
    154         nx.is_isomorphic(K5,G)
    155 
    156 
    157     def test_relabel_selfloop(self):
    158         G = nx.DiGraph([(1, 1), (1, 2), (2, 3)])
    159         G = nx.relabel_nodes(G, {1: 'One', 2: 'Two', 3: 'Three'}, copy=False)
    160         assert_equal(sorted(G.nodes()),['One','Three','Two'])
    161         G = nx.MultiDiGraph([(1, 1), (1, 2), (2, 3)])
    162         G = nx.relabel_nodes(G, {1: 'One', 2: 'Two', 3: 'Three'}, copy=False)
    163         assert_equal(sorted(G.nodes()),['One','Three','Two'])
    164