From 5f8de423f190bbb79a62f804151bc24824fa32d8 Mon Sep 17 00:00:00 2001
From: "Matt A. Tobin" <mattatobin@localhost.localdomain>
Date: Fri, 2 Feb 2018 04:16:08 -0500
Subject: Add m-esr52 at 52.6.0

---
 python/altgraph/altgraph_tests/test_dot.py | 370 +++++++++++++++++++++++++++++
 1 file changed, 370 insertions(+)
 create mode 100644 python/altgraph/altgraph_tests/test_dot.py

(limited to 'python/altgraph/altgraph_tests/test_dot.py')

diff --git a/python/altgraph/altgraph_tests/test_dot.py b/python/altgraph/altgraph_tests/test_dot.py
new file mode 100644
index 000000000..83993dad5
--- /dev/null
+++ b/python/altgraph/altgraph_tests/test_dot.py
@@ -0,0 +1,370 @@
+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()
-- 
cgit v1.2.3