class ParserTestCase(unittest.TestCase):
"""Test the ``Parser``."""
def setUp(self) -> None:
self.parser = Parser({})
self.tokens = [
(1, "a", "11"),
(2, "b", "12"),
(3, "c", "13"),
(4, "b", "14"),
(5, "c", "15"),
]
def test_end_continue(self) -> None:
"""Ensure end nodes are inserted before continue tokens."""
self.parser.continue_tokens = ["b"]
nodes = list(self.parser.end_continue(self.tokens))
assert 7 == len(nodes)
assert (2, "end", "") == nodes[1]
assert (2, "b", "12") == nodes[2]
assert (4, "end", "") == nodes[4]
assert (4, "b", "14") == nodes[5]
def test_parse_unchanged(self) -> None:
"""If there is no parser tokens defined the result is unchanged
input.
"""
nodes = list(self.parser.parse(self.tokens))
assert self.tokens == nodes
def test_parse_with_rules(self) -> None:
"""Ensure the rules applied."""
self.parser.rules["a"] = lambda value: value + "100"
self.parser.rules["b"] = lambda value: value + "10"
nodes = list(self.parser.parse(self.tokens))
assert (1, "a", "11100") == nodes[0]
assert (2, "b", "1210") == nodes[1]
assert (4, "b", "1410") == nodes[3]
def test_out_tokens(self) -> None:
"""Tokens from ``out_tokens`` are combined together into a single
node.
"""
self.parser.out_tokens = ["a", "b"]
nodes = list(self.parser.parse(self.tokens))
assert 4 == len(nodes)
assert (1, "out", [(1, "a", "11"), (2, "b", "12")]) == nodes[0]
assert (4, "out", [(4, "b", "14")]) == nodes[2]
self.parser.out_tokens = ["b", "c"]
nodes = list(self.parser.parse(self.tokens))
assert 2 == len(nodes)
assert (
2,
"out",
[(2, "b", "12"), (3, "c", "13"), (4, "b", "14"), (5, "c", "15")],
) == nodes[1]
def test_compound(self) -> None:
""""""
self.parser.compound_tokens = ["b"]
self.parser.end_tokens = ["c"]
nodes = list(self.parser.parse(self.tokens))
assert 3 == len(nodes)
assert (2, "b", ("12", [(3, "c", "13")])) == nodes[1]
assert (4, "b", ("14", [(5, "c", "15")])) == nodes[2]
class ParserTestCase(unittest.TestCase):
""" Test the ``Parser``.
"""
def setUp(self):
from wheezy.template.parser import Parser
self.parser = Parser({})
self.tokens = [
(1, 'a', 11),
(2, 'b', 12),
(3, 'c', 13),
(4, 'b', 14),
(5, 'c', 15),
]
def test_end_continue(self):
""" Ensure end nodes are inserted before continue tokens.
"""
self.parser.continue_tokens = ['b']
nodes = list(self.parser.end_continue(self.tokens))
assert 7 == len(nodes)
assert (2, 'end', None) == nodes[1]
assert (2, 'b', 12) == nodes[2]
assert (4, 'end', None) == nodes[4]
assert (4, 'b', 14) == nodes[5]
def test_parse_unchanged(self):
""" If there is no parser tokens defined the result is unchanged
input.
"""
nodes = list(self.parser.parse(self.tokens))
assert self.tokens == nodes
def test_parse_with_rules(self):
""" Ensure the rules applied.
"""
self.parser.rules['a'] = lambda value: value * 100
self.parser.rules['b'] = lambda value: value * 10
nodes = list(self.parser.parse(self.tokens))
assert (1, 'a', 1100) == nodes[0]
assert (2, 'b', 120) == nodes[1]
assert (4, 'b', 140) == nodes[3]
def test_out_tokens(self):
""" Tokens from ``out_tokens`` are combined together into a single
node.
"""
self.parser.out_tokens = ['a', 'b']
nodes = list(self.parser.parse(self.tokens))
assert 4 == len(nodes)
assert (1, 'out', [(1, 'a', 11), (2, 'b', 12)]) == nodes[0]
assert (4, 'out', [(4, 'b', 14)]) == nodes[2]
self.parser.out_tokens = ['b', 'c']
nodes = list(self.parser.parse(self.tokens))
assert 2 == len(nodes)
assert (2, 'out', [(2, 'b', 12), (3, 'c', 13), (4, 'b', 14),
(5, 'c', 15)]) == nodes[1]
def test_compound(self):
"""
"""
self.parser.compound_tokens = ['b']
self.parser.end_tokens = ['c']
nodes = list(self.parser.parse(self.tokens))
assert 3 == len(nodes)
assert (2, 'b', (12, [(3, 'c', 13)])) == nodes[1]
assert (4, 'b', (14, [(5, 'c', 15)])) == nodes[2]
class ParserTestCase(unittest.TestCase):
""" Test the ``Parser``.
"""
def setUp(self):
from wheezy.template.parser import Parser
self.parser = Parser({})
self.tokens = [
(1, 'a', 11),
(2, 'b', 12),
(3, 'c', 13),
(4, 'b', 14),
(5, 'c', 15),
]
def test_end_continue(self):
""" Ensure end nodes are inserted before continue tokens.
"""
self.parser.continue_tokens = ['b']
nodes = list(self.parser.end_continue(self.tokens))
assert 7 == len(nodes)
assert (2, 'end', None) == nodes[1]
assert (2, 'b', 12) == nodes[2]
assert (4, 'end', None) == nodes[4]
assert (4, 'b', 14) == nodes[5]
def test_parse_unchanged(self):
""" If there is no parser tokens defined the result is unchanged
input.
"""
nodes = list(self.parser.parse(self.tokens))
assert self.tokens == nodes
def test_parse_with_rules(self):
""" Ensure the rules applied.
"""
self.parser.rules['a'] = lambda value: value * 100
self.parser.rules['b'] = lambda value: value * 10
nodes = list(self.parser.parse(self.tokens))
assert (1, 'a', 1100) == nodes[0]
assert (2, 'b', 120) == nodes[1]
assert (4, 'b', 140) == nodes[3]
def test_out_tokens(self):
""" Tokens from ``out_tokens`` are combined together into a single
node.
"""
self.parser.out_tokens = ['a', 'b']
nodes = list(self.parser.parse(self.tokens))
assert 4 == len(nodes)
assert (1, 'out', [(1, 'a', 11), (2, 'b', 12)]) == nodes[0]
assert (4, 'out', [(4, 'b', 14)]) == nodes[2]
self.parser.out_tokens = ['b', 'c']
nodes = list(self.parser.parse(self.tokens))
assert 2 == len(nodes)
assert (2, 'out', [(2, 'b', 12), (3, 'c', 13),
(4, 'b', 14), (5, 'c', 15)]) == nodes[1]
def test_compound(self):
"""
"""
self.parser.compound_tokens = ['b']
self.parser.end_tokens = ['c']
nodes = list(self.parser.parse(self.tokens))
assert 3 == len(nodes)
assert (2, 'b', (12, [(3, 'c', 13)])) == nodes[1]
assert (4, 'b', (14, [(5, 'c', 15)])) == nodes[2]
