def test_postorder_do(self): tup = (6, 'a', (4, (2, 'b'), 'd'), 'f') root = parsetree.fromtuple(tup) l = [] fn = lambda node : l.append(node.value) root.postorder_do(fn) self.assertListEqual(l, ['a', 'b', 2, 'd', 4, 'f', 6])
def test_terminal_values_00(self): """Tests type of Leafs.""" tup = (1, (2, 'a', (3, 'b')), (4, 'c'), 'd') root = parsetree.fromtuple(tup) self.assertEqual(''.join([n.value for n in root.leaves]), 'abcd') self.assertAllTrue([isinstance(n, TerminalNode) for n in root.leaves]) self.assertAllTrue([isinstance(n, str) for n in root.leaves])
def test_preorder_do_01(self): tup = (0, 'b', (2, (3, 'e'), 'f'), 'g') root = parsetree.fromtuple(tup) l = [] fn = lambda node : l.append(node.value) root.preorder_do(fn) self.assertListEqual(l, [0, 'b', 2, 3, 'e', 'f', 'g'])
def test_match_04(self): """Tests shorthand for closure [:1].""" _ = Any() root = parsetree.fromtuple((0, (1, 'a'), (1, 'b'))) self.assertMatch(root, Tup(0, ['a'], 'b',)) self.assertMatch(root, Tup(0, ['a'], 'b', ['c'])) self.assertMatch(root, Tup(0, 'a', ['a'], 'b', ['c']))
def test_iter_match_04(self): """Tests application of callback on ConcatenationPattern.""" l = [] root = parsetree.fromtuple((0, (1, 'a'), (2, (1, 'b')))) pattern = Tup(2, 'b') % l.append root.preorder_do(pattern.matches) self.assertListEqual([n.totuple() for n in l], [(2, (1, 'b'))])
def test_iter_match_00(self): """Tests application of callback during iteration.""" l = [] A = Lit('a') root = parsetree.fromtuple((1, (1, 'a')),) pattern = Tup(1, A % (lambda n : l.append(n.string))) root.preorder_do(pattern.matches) self.assertListEqual(l, ['a'])
def test_traversal(self): """Tests equivalent traversal behaviour.""" t = (1, (2, (1, 'a')), (2, 'b'), (3, (2, (4, 'x', 'y')))) tuple_iter = tupletraversal.preorder(t) root = parsetree.fromtuple(t) node_iter = root.preorder() for t, n in zip(tuple_iter, node_iter): self.assertEqual(t, n)
def test_getitem(self): tup = (0, (1, (2, 'a'), 'b',), 'c') root = parsetree.fromtuple(tup) self.assertEqual(len(root), 3) self.assertTupleEqual(root.totuple(), (0, (1, (2, 'a'), 'b',), 'c')) self.assertTupleEqual(root[1].totuple(), (1, (2, 'a'), 'b',)) self.assertEqual(root[2], 'c') self.assertRaises(IndexError, root.__getitem__, 3)
def test_callback(self): """Tests callback execution after closure.""" tup = (0, (1, 'a'), (1, 'a'), (1, 'a')) more = ~Any() l = [] root = parsetree.fromtuple(tup) self.assertMatch(root, Tup(0, more) % l.append) self.assertListEqual(l, [tup])
def test_preorder_do_00(self): """Tests preorder traversal of ParseTreeNode.""" tup = (1, (2, 'a'),) root = parsetree.fromtuple(tup) l = [] root.preorder_do(l.append) self.assertListEqual(l, [(1, (2, 'a'),), (2, 'a'), 'a'])
def test_iter_match_06(self): """Tests application of callback during iteration with union pattern.""" l = [] _ = Any() root = parsetree.fromtuple((1, (2, (3, (1, 'a')), (3, 'b')))) pattern = (Tup(3, 'a') | Tup(3, 'x')) % (lambda n : l.append(n.totuple())) root.preorder_do(pattern.matches) self.assertListEqual(l, [(3, (1, 'a'))])
def test_from_and_to_tuple_00(self): """Asserts equality of conversion from parsed pnode back to tuple.""" tup = (1, 'a') root = parsetree.fromtuple(tup) self.assertTupleEqual(tup, root.totuple()) self.assertTrue(root.children) self.assertEqual(len(root.children), 1) child = root.children[0] self.assertFalse(child.children)
def test_iter_01(self): root = parsetree.fromtuple((1, (2, 'a'), (3, (4, 'b')), 'c')) self.assertListEqual([c for c in root], [1, (2, 'a'), (3, (4, 'b')), 'c']) self.assertTrue(isinstance(root[0], int)) self.assertTrue(isinstance(root[1], tuple)) self.assertTrue(isinstance(root[2], tuple)) self.assertTrue(isinstance(root[3], str))
def test_iter_match_05(self): """Tests multiple matches in one tree.""" l = [] _ = Any() root = parsetree.fromtuple((1, (2, (1, 'a')), (2, 'b'), (3, (2, (4, 'x', 'y'))))) pattern = Tup(2, _) % l.append root.preorder_do(pattern.matches) self.assertListEqual([n.totuple() for n in l], [(2, (1, 'a')), (2, 'b'), (2, (4, 'x', 'y'))])
def test_iter_match_01(self): """Tests application of callback during iteration with multiple matches.""" l = [] A = Lit('a') _ = Any() root = parsetree.fromtuple((1, (2, 'a'), (3, 'a'))) pattern = Tup(_, A % (lambda n : l.append(n.string))) root.preorder_do(pattern.matches) self.assertListEqual(l, ['a', 'a'])
def test_nonterminal_type(self): """Assert type of nonterminal node.""" root = parsetree.fromtuple((0, 'a')) self.assertTrue(isinstance(root, tuple)) self.assertTrue(isinstance(root, NonTerminalNode)) self.assertTrue(root[0] == 0) self.assertTrue(isinstance(root[0], int)) self.assertTrue(root[1] == 'a') self.assertFalse(isinstance(root[1], tuple)) self.assertTrue(isinstance(root[1], TerminalNode)) self.assertTrue(isinstance(root[1], str))
def test_from_and_to_tuple_03(self): """Asserts equality of conversion from parsed parsetree back to tuple for whole library.""" for py in python_library(): sys.stdout.write('{}...'.format(py)) pt = parse(py) root = parsetree.fromtuple(pt) leaves = root.leaves self.assertTupleEqual(pt, root.totuple()) self.assertAllTrue([isinstance(n, TerminalNode) for n in leaves]) self.assertAllTrue([isinstance(n, str) for n in leaves]) print('PASS')
def test_traversal_library(self): """Tests equivalent traversal behaviour for all files in library.""" for py in python_library(): sys.stdout.write('{}...'.format(py)) pt = parse(py) root = parsetree.fromtuple(pt) tuple_iter = tupletraversal.preorder(pt) node_iter = root.preorder() for t, n in zip(tuple_iter, node_iter): self.assertEqual(t, n) print('PASS')
def test_match_02(self): """Tests tuple match variations.""" _ = Any() root = parsetree.fromtuple((0, (1, 'a'))) self.assertMatch(root, Tup(0, _,)) self.assertMatch(root, Tup(0, 'a')) self.assertMatch(root, Tup(_, 'a')) self.assertMatch(root, Tup(Lit(0), Terminal('a'))) self.denyMatch(root, Tup(_, Lit('a'))) self.denyMatch(root, Tup(0, Lit('a'))) self.denyMatch(root, Tup(_, Tup('a'))) self.denyMatch(root, Tup(_, (('a',),)))
def test_tuplevalue_00(self): """Tests application of callback during iteration with multiple matches.""" l = [] root = parsetree.fromtuple((1, (2, (1, 'a')), (3, (1, 'b')))) pattern = Any() % (lambda n : l.append(n.tuplevalue())) root.preorder_do(pattern.matches) self.assertListEqual(l, [(1, (2, (1, 'a')), (3, (1, 'b'))), (2, (1, 'a')), (1, 'a'), 'a', (3, (1, 'b')), (1, 'b'), 'b'])
def test_from_tuple_00(self): """Test creation of nonterminal nodes.""" node = parsetree.fromtuple((1, 'a', (2, 'b'))) self.assertTrue(isinstance(node, NonTerminalNode)) self.assertTrue(isinstance(node, tuple)) self.assertFalse(node.isleaf()) self.assertRaises(TypeError, parsetree.fromtuple) self.assertRaises(TypeError, parsetree.fromtuple, (1,)) self.assertRaises(TypeError, parsetree.fromtuple, ((),)) self.assertRaises(TypeError, parsetree.fromtuple, ('a',)) self.assertRaises(TypeError, parsetree.fromtuple, ('a', 'b')) self.assertRaises(TypeError, parsetree.fromtuple, 'a') self.assertRaises(TypeError, parsetree.fromtuple, None) self.assertRaises(TypeError, parsetree.fromtuple, True) self.assertRaises(TypeError, parsetree.fromtuple, False) self.assertRaises(TypeError, parsetree.fromtuple, 0) self.assertRaises(TypeError, parsetree.fromtuple, 1) self.assertRaises(TypeError, parsetree.fromtuple, '') self.assertRaises(TypeError, parsetree.fromtuple, []) self.assertRaises(TypeError, parsetree.fromtuple, ((),'a')) self.assertRaises(TypeError, parsetree.fromtuple, (1, 23))
def test_tree(self): """Tests consistency of entire tree.""" tup = (1, (2, 'a', 'b'),) root = parsetree.fromtuple(tup) self.assertTrue(isinstance(root, NonTerminalNode)) self.assertFalse(isinstance(root, TerminalNode)) self.assertTrue(isinstance(root, tuple)) self.assertTrue(root.isroot()) self.assertFalse(root.isleaf()) self.assertTupleEqual(tup, root) self.assertEqual(1, root[0]) self.assertTupleEqual(tup, root.totuple()) child = root[1] self.assertTrue(isinstance(child, NonTerminalNode)) self.assertFalse(isinstance(child, TerminalNode)) self.assertTrue(isinstance(child, tuple)) self.assertFalse(child.isroot()) self.assertFalse(child.isleaf()) self.assertTupleEqual(tup[1], child) self.assertTupleEqual(tup[1], child.totuple()) leaf = child[1] self.assertFalse(isinstance(leaf, NonTerminalNode)) self.assertTrue(isinstance(leaf, TerminalNode)) self.assertFalse(isinstance(leaf, tuple)) self.assertFalse(leaf.isroot()) self.assertTrue(leaf.isleaf()) self.assertEqual(tup[1][1], leaf) self.assertEqual('a', leaf[0]) self.assertRaises(AttributeError, leaf.__getattribute__, 'totuple') self.assertEqual(root.leaves[0], leaf) self.assertEqual(child.root, root) self.assertEqual(leaf.root, root) self.assertEqual(root.children, [child]) self.assertEqual(child.children[0], leaf) self.assertEqual(child.children[1], 'b') self.assertEqual(leaf.children, [])
def test_from_and_to_tuple_02(self): """Asserts equality of conversion from parsed ptnode back to tuple.""" tup = (1, (2, 'three'), (0, '')) root = parsetree.fromtuple(tup) self.assertTupleEqual(tup, root.totuple())
def test_iter_00(self): tup = (1, 'a') root = parsetree.fromtuple(tup) self.assertListEqual([n for n in root], [1, 'a'])
def test_match_01(self): """Tests simple literal match.""" self.denyMatch(parsetree.fromtuple((0, (1, 'a'))), Lit('a'))
def test_match_03(self): """Tests tuple match variations.""" more = ~Any() root = parsetree.fromtuple((0, (1, 'a'), (1, 'a'), (1, 'a')),) self.assertMatch(root, Tup(0, more))