1 # :set encoding=utf8

     2 

     3 """

     4     Unit tests for qmsk.web.tree_parse

     5 """

     6 

     7 import unittest

     8 import tree_parse

     9 

    10 class TestTreeParse (unittest.TestCase) :

    11     VALID = """\

    12 foo

    13   bar

    14    quux

    15 

    16   asdf

    17         further

    18          still

    19 

    20   and back

    21 """.split('\n')

    22 

    23     def test_read_lines_valid (self) :

    24         self.assertEquals(list(tree_parse._read_lines(self.VALID)), [

    25             (1, 0,  "foo"),

    26             (2, 2,  "bar"),

    27             (3, 3,  "quux"),

    28             (5, 2,  "asdf"),

    29             (6, 8,  "further"),

    30             (7, 9,  "still"),

    31             (9, 2,  "and back"),

    32         ])

    33 

    34     def _parse (self, *lines, **args) :

    35         return list(tree_parse._read_lines(lines, **args))

    36     

    37     def test_read_lines_decode (self) :

    38         data_unicode = u'föö'

    39         data_raw = 'föö'

    40 

    41         self.assertEquals(self._parse(data_unicode.encode('utf8'), charset='utf8'), [(1, 0, data_unicode)])

    42         self.assertEquals(self._parse(data_unicode, charset=None), [(1, 0, data_unicode)])

    43         self.assertEquals(self._parse(data_raw, charset=None), [(1, 0, data_raw)])

    44         self.assertRaises(UnicodeDecodeError, self._parse, data_raw, charset='ascii')

    45     

    46     def test_read_lines_stop (self) :

    47         self.assertEquals(self._parse(" : foo"), [(1, 1, ": foo")])

    48         self.assertEquals(self._parse("    : foo", stop_tokens=':'), [(1, 0, ": foo")])

    49     

    50     def test_read_lines_empty (self) :

    51         self.assertEquals(self._parse(*("foo\n\n  bar".split('\n'))), [(1, 0, "foo"), (3, 2, "bar")])

    52 

    53     def test_read_lines_strip (self) :

    54         self.assertEquals(self._parse(" foo "), [(1, 1, "foo")])

    55     

    56     def _do (self, *lines, **args) :

    57         return tree_parse.parse(lines, **args)

    58 

    59     def test_parse_valid (self) :

    60         self.assertEquals(self._do(*self.VALID), 

    61             (1, "foo", [

    62                 (2, "bar", [

    63                     (3, "quux", []),

    64                 ]),

    65                 (5, "asdf", [

    66                     (6, "further", [

    67                         (7, "still", []),

    68                     ]),

    69                 ]),

    70                 (9, "and back", [])

    71             ])

    72         )

    73     

    74     def test_parse_invalid (self) :

    75         self.assertRaises(tree_parse.TreeParseError, self._do, "foo", "  bar", " quux")

    76     

    77     # XXX: don't test root, as that's known-broken still

    78