зеркало из https://github.com/mozilla/gecko-dev.git
371 строка
10 KiB
Python
371 строка
10 KiB
Python
import unittest
|
|
import os
|
|
|
|
from altgraph import Dot
|
|
from altgraph import Graph
|
|
from altgraph import GraphError
|
|
|
|
|
|
class TestDot (unittest.TestCase):
|
|
|
|
def test_constructor(self):
|
|
g = Graph.Graph([
|
|
(1,2),
|
|
(1,3),
|
|
(1,4),
|
|
(2,4),
|
|
(2,6),
|
|
(2,7),
|
|
(7,4),
|
|
(6,1),
|
|
]
|
|
)
|
|
|
|
dot = Dot.Dot(g)
|
|
|
|
self.assertEqual(dot.name, 'G')
|
|
self.assertEqual(dot.attr, {})
|
|
self.assertEqual(dot.temp_dot, 'tmp_dot.dot')
|
|
self.assertEqual(dot.temp_neo, 'tmp_neo.dot')
|
|
self.assertEqual(dot.dot, 'dot')
|
|
self.assertEqual(dot.dotty, 'dotty')
|
|
self.assertEqual(dot.neato, 'neato')
|
|
self.assertEqual(dot.type, 'digraph')
|
|
|
|
self.assertEqual(dot.nodes, dict([(x, {}) for x in g]))
|
|
|
|
edges = {}
|
|
for head in g:
|
|
edges[head] = {}
|
|
for tail in g.out_nbrs(head):
|
|
edges[head][tail] = {}
|
|
|
|
self.assertEqual(dot.edges[1], edges[1])
|
|
self.assertEqual(dot.edges, edges)
|
|
|
|
|
|
dot = Dot.Dot(g, nodes=[1,2],
|
|
edgefn=lambda node: list(sorted(g.out_nbrs(node)))[:-1],
|
|
nodevisitor=lambda node: {'label': node},
|
|
edgevisitor=lambda head, tail: {'label': (head, tail) },
|
|
name="testgraph",
|
|
dot='/usr/local/bin/dot',
|
|
dotty='/usr/local/bin/dotty',
|
|
neato='/usr/local/bin/neato',
|
|
graphtype="graph")
|
|
|
|
self.assertEqual(dot.name, 'testgraph')
|
|
self.assertEqual(dot.attr, {})
|
|
self.assertEqual(dot.temp_dot, 'tmp_dot.dot')
|
|
self.assertEqual(dot.temp_neo, 'tmp_neo.dot')
|
|
self.assertEqual(dot.dot, '/usr/local/bin/dot')
|
|
self.assertEqual(dot.dotty, '/usr/local/bin/dotty')
|
|
self.assertEqual(dot.neato, '/usr/local/bin/neato')
|
|
self.assertEqual(dot.type, 'graph')
|
|
|
|
self.assertEqual(dot.nodes, dict([(x, {'label': x}) for x in [1,2]]))
|
|
|
|
edges = {}
|
|
for head in [1,2]:
|
|
edges[head] = {}
|
|
for tail in list(sorted(g.out_nbrs(head)))[:-1]:
|
|
if tail not in [1,2]: continue
|
|
edges[head][tail] = {'label': (head, tail) }
|
|
|
|
self.assertEqual(dot.edges[1], edges[1])
|
|
self.assertEqual(dot.edges, edges)
|
|
|
|
self.assertRaises(GraphError, Dot.Dot, g, nodes=[1,2, 9])
|
|
|
|
def test_style(self):
|
|
g = Graph.Graph([])
|
|
|
|
dot = Dot.Dot(g)
|
|
|
|
self.assertEqual(dot.attr, {})
|
|
|
|
dot.style(key='value')
|
|
self.assertEqual(dot.attr, {'key': 'value'})
|
|
|
|
dot.style(key2='value2')
|
|
self.assertEqual(dot.attr, {'key2': 'value2'})
|
|
|
|
def test_node_style(self):
|
|
g = Graph.Graph([
|
|
(1,2),
|
|
(1,3),
|
|
(1,4),
|
|
(2,4),
|
|
(2,6),
|
|
(2,7),
|
|
(7,4),
|
|
(6,1),
|
|
]
|
|
)
|
|
|
|
dot = Dot.Dot(g)
|
|
|
|
self.assertEqual(dot.nodes[1], {})
|
|
|
|
dot.node_style(1, key='value')
|
|
self.assertEqual(dot.nodes[1], {'key': 'value'})
|
|
|
|
dot.node_style(1, key2='value2')
|
|
self.assertEqual(dot.nodes[1], {'key2': 'value2'})
|
|
self.assertEqual(dot.nodes[2], {})
|
|
|
|
dot.all_node_style(key3='value3')
|
|
for n in g:
|
|
self.assertEqual(dot.nodes[n], {'key3': 'value3'})
|
|
|
|
self.assertTrue(9 not in dot.nodes)
|
|
dot.node_style(9, key='value')
|
|
self.assertEqual(dot.nodes[9], {'key': 'value'})
|
|
|
|
def test_edge_style(self):
|
|
g = Graph.Graph([
|
|
(1,2),
|
|
(1,3),
|
|
(1,4),
|
|
(2,4),
|
|
(2,6),
|
|
(2,7),
|
|
(7,4),
|
|
(6,1),
|
|
]
|
|
)
|
|
|
|
dot = Dot.Dot(g)
|
|
|
|
self.assertEqual(dot.edges[1][2], {})
|
|
dot.edge_style(1,2, foo='bar')
|
|
self.assertEqual(dot.edges[1][2], {'foo': 'bar'})
|
|
|
|
dot.edge_style(1,2, foo2='2bar')
|
|
self.assertEqual(dot.edges[1][2], {'foo2': '2bar'})
|
|
|
|
self.assertEqual(dot.edges[1][3], {})
|
|
|
|
self.assertFalse(6 in dot.edges[1])
|
|
dot.edge_style(1,6, foo2='2bar')
|
|
self.assertEqual(dot.edges[1][6], {'foo2': '2bar'})
|
|
|
|
self.assertRaises(GraphError, dot.edge_style, 1, 9, a=1)
|
|
self.assertRaises(GraphError, dot.edge_style, 9, 1, a=1)
|
|
|
|
|
|
def test_iter(self):
|
|
g = Graph.Graph([
|
|
(1,2),
|
|
(1,3),
|
|
(1,4),
|
|
(2,4),
|
|
(2,6),
|
|
(2,7),
|
|
(7,4),
|
|
(6,1),
|
|
]
|
|
)
|
|
|
|
dot = Dot.Dot(g)
|
|
dot.style(graph="foobar")
|
|
dot.node_style(1, key='value')
|
|
dot.node_style(2, key='another', key2='world')
|
|
dot.edge_style(1,4, key1='value1', key2='value2')
|
|
dot.edge_style(2,4, key1='valueA')
|
|
|
|
self.assertEqual(list(iter(dot)), list(dot.iterdot()))
|
|
|
|
for item in dot.iterdot():
|
|
self.assertTrue(isinstance(item, str))
|
|
|
|
first = list(dot.iterdot())[0]
|
|
self.assertEqual(first, "digraph %s {\n"%(dot.name,))
|
|
|
|
dot.type = 'graph'
|
|
first = list(dot.iterdot())[0]
|
|
self.assertEqual(first, "graph %s {\n"%(dot.name,))
|
|
|
|
dot.type = 'foo'
|
|
self.assertRaises(GraphError, list, dot.iterdot())
|
|
dot.type = 'digraph'
|
|
|
|
self.assertEqual(list(dot), [
|
|
'digraph G {\n',
|
|
'graph="foobar";',
|
|
'\n',
|
|
|
|
'\t"1" [',
|
|
'key="value",',
|
|
'];\n',
|
|
|
|
'\t"2" [',
|
|
'key="another",',
|
|
'key2="world",',
|
|
'];\n',
|
|
|
|
'\t"3" [',
|
|
'];\n',
|
|
|
|
'\t"4" [',
|
|
'];\n',
|
|
|
|
'\t"6" [',
|
|
'];\n',
|
|
|
|
'\t"7" [',
|
|
'];\n',
|
|
|
|
'\t"1" -> "2" [',
|
|
'];\n',
|
|
|
|
'\t"1" -> "3" [',
|
|
'];\n',
|
|
|
|
'\t"1" -> "4" [',
|
|
'key1="value1",',
|
|
'key2="value2",',
|
|
'];\n',
|
|
|
|
'\t"2" -> "4" [',
|
|
'key1="valueA",',
|
|
'];\n',
|
|
|
|
'\t"2" -> "6" [',
|
|
'];\n',
|
|
|
|
'\t"2" -> "7" [',
|
|
'];\n',
|
|
|
|
'\t"6" -> "1" [',
|
|
'];\n',
|
|
|
|
'\t"7" -> "4" [',
|
|
'];\n',
|
|
'}\n'])
|
|
|
|
|
|
def test_save(self):
|
|
g = Graph.Graph([
|
|
(1,2),
|
|
(1,3),
|
|
(1,4),
|
|
(2,4),
|
|
(2,6),
|
|
(2,7),
|
|
(7,4),
|
|
(6,1),
|
|
]
|
|
)
|
|
|
|
dot = Dot.Dot(g)
|
|
dot.style(graph="foobar")
|
|
dot.node_style(1, key='value')
|
|
dot.node_style(2, key='another', key2='world')
|
|
dot.edge_style(1,4, key1='value1', key2='value2')
|
|
dot.edge_style(2,4, key1='valueA')
|
|
|
|
fn = 'test_dot.dot'
|
|
self.assertTrue(not os.path.exists(fn))
|
|
|
|
try:
|
|
dot.save_dot(fn)
|
|
|
|
fp = open(fn, 'r')
|
|
data = fp.read()
|
|
fp.close()
|
|
self.assertEqual(data, ''.join(dot))
|
|
|
|
finally:
|
|
if os.path.exists(fn):
|
|
os.unlink(fn)
|
|
|
|
|
|
def test_img(self):
|
|
g = Graph.Graph([
|
|
(1,2),
|
|
(1,3),
|
|
(1,4),
|
|
(2,4),
|
|
(2,6),
|
|
(2,7),
|
|
(7,4),
|
|
(6,1),
|
|
]
|
|
)
|
|
|
|
dot = Dot.Dot(g, dot='/usr/local/bin/!!dot', dotty='/usr/local/bin/!!dotty', neato='/usr/local/bin/!!neato')
|
|
dot.style(size='10,10', rankdir='RL', page='5, 5' , ranksep=0.75)
|
|
dot.node_style(1, label='BASE_NODE',shape='box', color='blue')
|
|
dot.node_style(2, style='filled', fillcolor='red')
|
|
dot.edge_style(1,4, style='dotted')
|
|
dot.edge_style(2,4, arrowhead='dot', label='binds', labelangle='90')
|
|
|
|
system_cmds = []
|
|
def fake_system(cmd):
|
|
system_cmds.append(cmd)
|
|
return None
|
|
|
|
try:
|
|
real_system = os.system
|
|
os.system = fake_system
|
|
|
|
system_cmds = []
|
|
dot.save_img('foo')
|
|
self.assertEqual(system_cmds, ['/usr/local/bin/!!dot -Tgif tmp_dot.dot -o foo.gif'])
|
|
|
|
system_cmds = []
|
|
dot.save_img('foo', file_type='jpg')
|
|
self.assertEqual(system_cmds, ['/usr/local/bin/!!dot -Tjpg tmp_dot.dot -o foo.jpg'])
|
|
|
|
system_cmds = []
|
|
dot.save_img('bar', file_type='jpg', mode='neato')
|
|
self.assertEqual(system_cmds, [
|
|
'/usr/local/bin/!!neato -o tmp_dot.dot tmp_neo.dot',
|
|
'/usr/local/bin/!!dot -Tjpg tmp_dot.dot -o bar.jpg',
|
|
])
|
|
|
|
system_cmds = []
|
|
dot.display()
|
|
self.assertEqual(system_cmds, [
|
|
'/usr/local/bin/!!dotty tmp_dot.dot'
|
|
])
|
|
|
|
system_cmds = []
|
|
dot.display(mode='neato')
|
|
self.assertEqual(system_cmds, [
|
|
'/usr/local/bin/!!neato -o tmp_dot.dot tmp_neo.dot',
|
|
'/usr/local/bin/!!dotty tmp_dot.dot'
|
|
])
|
|
|
|
finally:
|
|
if os.path.exists(dot.temp_dot):
|
|
os.unlink(dot.temp_dot)
|
|
if os.path.exists(dot.temp_neo):
|
|
os.unlink(dot.temp_neo)
|
|
os.system = real_system
|
|
|
|
if os.path.exists('/usr/local/bin/dot') and os.path.exists('/usr/local/bin/neato'):
|
|
try:
|
|
dot.dot='/usr/local/bin/dot'
|
|
dot.neato='/usr/local/bin/neato'
|
|
self.assertFalse(os.path.exists('foo.gif'))
|
|
dot.save_img('foo')
|
|
self.assertTrue(os.path.exists('foo.gif'))
|
|
os.unlink('foo.gif')
|
|
|
|
self.assertFalse(os.path.exists('foo.gif'))
|
|
dot.save_img('foo', mode='neato')
|
|
self.assertTrue(os.path.exists('foo.gif'))
|
|
os.unlink('foo.gif')
|
|
|
|
finally:
|
|
if os.path.exists(dot.temp_dot):
|
|
os.unlink(dot.temp_dot)
|
|
if os.path.exists(dot.temp_neo):
|
|
os.unlink(dot.temp_neo)
|
|
|
|
|
|
if __name__ == "__main__": # pragma: no cover
|
|
unittest.main()
|