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))
