"Test pyparse, coverage 96%." from idlelib import pyparse import unittest from collections import namedtuple class ParseMapTest(unittest.TestCase): def test_parsemap(self): keepwhite = {ord(c): ord(c) for c in ' \t\n\r'} mapping = pyparse.ParseMap(keepwhite) self.assertEqual(mapping[ord('\t')], ord('\t')) self.assertEqual(mapping[ord('a')], ord('x')) self.assertEqual(mapping[1000], ord('x')) def test_trans(self): # trans is the production instance of ParseMap, used in _study1 parser = pyparse.Parser(4, 4) self.assertEqual('\t a([{b}])b"c\'d\n'.translate(pyparse.trans), 'xxx(((x)))x"x\'x\n') class PyParseTest(unittest.TestCase): @classmethod def setUpClass(cls): cls.parser = pyparse.Parser(indentwidth=4, tabwidth=4) @classmethod def tearDownClass(cls): del cls.parser def test_init(self): self.assertEqual(self.parser.indentwidth, 4) self.assertEqual(self.parser.tabwidth, 4) def test_set_code(self): eq = self.assertEqual p = self.parser setcode = p.set_code # Not empty and doesn't end with newline. with self.assertRaises(AssertionError): setcode('a') tests = ('', 'a\n') for string in tests: with self.subTest(string=string): setcode(string) eq(p.code, string) eq(p.study_level, 0) def test_find_good_parse_start(self): eq = self.assertEqual p = self.parser setcode = p.set_code start = p.find_good_parse_start def char_in_string_false(index): return False # First line starts with 'def' and ends with ':', then 0 is the pos. setcode('def spam():\n') eq(start(char_in_string_false), 0) # First line begins with a keyword in the list and ends # with an open brace, then 0 is the pos. This is how # hyperparser calls this function as the newline is not added # in the editor, but rather on the call to setcode. setcode('class spam( ' + ' \n') eq(start(char_in_string_false), 0) # Split def across lines. setcode('"""This is a module docstring"""\n' 'class C():\n' ' def __init__(self, a,\n' ' b=True):\n' ' pass\n' ) # Passing no value or non-callable should fail (issue 32989). with self.assertRaises(TypeError): start() with self.assertRaises(TypeError): start(False) # Make text look like a string. This returns pos as the start # position, but it's set to None. self.assertIsNone(start(is_char_in_string=lambda index: True)) # Make all text look like it's not in a string. This means that it # found a good start position. eq(start(char_in_string_false), 44) # If the beginning of the def line is not in a string, then it # returns that as the index. eq(start(is_char_in_string=lambda index: index > 44), 44) # If the beginning of the def line is in a string, then it # looks for a previous index. eq(start(is_char_in_string=lambda index: index >= 44), 33) # If everything before the 'def' is in a string, then returns None. # The non-continuation def line returns 44 (see below). eq(start(is_char_in_string=lambda index: index < 44), None) # Code without extra line break in def line - mostly returns the same # values. setcode('"""This is a module docstring"""\n' 'class C():\n' ' def __init__(self, a, b=True):\n' ' pass\n' ) eq(start(char_in_string_false), 44) eq(start(is_char_in_string=lambda index: index > 44), 44) eq(start(is_char_in_string=lambda index: index >= 44), 33) # When the def line isn't split, this returns which doesn't match the # split line test. eq(start(is_char_in_string=lambda index: index < 44), 44) def test_set_lo(self): code = ( '"""This is a module docstring"""\n' 'class C():\n' ' def __init__(self, a,\n' ' b=True):\n' ' pass\n' ) p = self.parser p.set_code(code) # Previous character is not a newline. with self.assertRaises(AssertionError): p.set_lo(5) # A value of 0 doesn't change self.code. p.set_lo(0) self.assertEqual(p.code, code) # An index that is preceded by a newline. p.set_lo(44) self.assertEqual(p.code, code[44:]) def test_study1(self): eq = self.assertEqual p = self.parser setcode = p.set_code study = p._study1 (NONE, BACKSLASH, FIRST, NEXT, BRACKET) = range(5) TestInfo = namedtuple('TestInfo', ['string', 'goodlines', 'continuation']) tests = ( TestInfo('', [0], NONE), # Docstrings. TestInfo('"""This is a complete docstring."""\n', [0, 1], NONE), TestInfo("'''This is a complete docstring.'''\n", [0, 1], NONE), TestInfo('"""This is a continued docstring.\n', [0, 1], FIRST), TestInfo("'''This is a continued docstring.\n", [0, 1], FIRST), TestInfo('"""Closing quote does not match."\n', [0, 1], FIRST), TestInfo('"""Bracket in docstring [\n', [0, 1], FIRST), TestInfo("'''Incomplete two line docstring.\n\n", [0, 2], NEXT), # Single-quoted strings. TestInfo('"This is a complete string."\n', [0, 1], NONE), TestInfo('"This is an incomplete string.\n', [0, 1], NONE), TestInfo("'This is more incomplete.\n\n", [0, 1, 2], NONE), # Comment (backslash does not continue comments). TestInfo('# Comment\\\n', [0, 1], NONE), # Brackets. TestInfo('("""Complete string in bracket"""\n', [0, 1], BRACKET), TestInfo('("""Open string in bracket\n', [0, 1], FIRST), TestInfo('a = (1 + 2) - 5 *\\\n', [0, 1], BACKSLASH), # No bracket. TestInfo('\n def function1(self, a,\n b):\n', [0, 1, 3], NONE), TestInfo('\n def function1(self, a,\\\n', [0, 1, 2], BRACKET), TestInfo('\n def function1(self, a,\n', [0, 1, 2], BRACKET), TestInfo('())\n', [0, 1], NONE), # Extra closer. TestInfo(')(\n', [0, 1], BRACKET), # Extra closer. # For the mismatched example, it doesn't look like continuation. TestInfo('{)(]\n', [0, 1], NONE), # Mismatched. ) for test in tests: with self.subTest(string=test.string): setcode(test.string) # resets study_level study() eq(p.study_level, 1) eq(p.goodlines, test.goodlines) eq(p.continuation, test.continuation) # Called again, just returns without reprocessing. self.assertIsNone(study()) def test_get_continuation_type(self): eq = self.assertEqual p = self.parser setcode = p.set_code gettype = p.get_continuation_type (NONE, BACKSLASH, FIRST, NEXT, BRACKET) = range(5) TestInfo = namedtuple('TestInfo', ['string', 'continuation']) tests = ( TestInfo('', NONE), TestInfo('"""This is a continuation docstring.\n', FIRST), TestInfo("'''This is a multiline-continued docstring.\n\n", NEXT), TestInfo('a = (1 + 2) - 5 *\\\n', BACKSLASH), TestInfo('\n def function1(self, a,\\\n', BRACKET) ) for test in tests: with self.subTest(string=test.string): setcode(test.string) eq(gettype(), test.continuation) def test_study2(self): eq = self.assertEqual p = self.parser setcode = p.set_code study = p._study2 TestInfo = namedtuple('TestInfo', ['string', 'start', 'end', 'lastch', 'openbracket', 'bracketing']) tests = ( TestInfo('', 0, 0, '', None, ((0, 0),)), TestInfo("'''This is a multiline continuation docstring.\n\n", 0, 48, "'", None, ((0, 0), (0, 1), (48, 0))), TestInfo(' # Comment\\\n', 0, 12, '', None, ((0, 0), (1, 1), (12, 0))), # A comment without a space is a special case TestInfo(' #Comment\\\n', 0, 0, '', None, ((0, 0),)), # Backslash continuation. TestInfo('a = (1 + 2) - 5 *\\\n', 0, 19, '*', None, ((0, 0), (4, 1), (11, 0))), # Bracket continuation with close. TestInfo('\n def function1(self, a,\n b):\n', 1, 48, ':', None, ((1, 0), (17, 1), (46, 0))), # Bracket continuation with unneeded backslash. TestInfo('\n def function1(self, a,\\\n', 1, 28, ',', 17, ((1, 0), (17, 1))), # Bracket continuation. TestInfo('\n def function1(self, a,\n', 1, 27, ',', 17, ((1, 0), (17, 1))), # Bracket continuation with comment at end of line with text. TestInfo('\n def function1(self, a, # End of line comment.\n', 1, 51, ',', 17, ((1, 0), (17, 1), (28, 2), (51, 1))), # Multi-line statement with comment line in between code lines. TestInfo(' a = ["first item",\n # Comment line\n "next item",\n', 0, 55, ',', 6, ((0, 0), (6, 1), (7, 2), (19, 1), (23, 2), (38, 1), (42, 2), (53, 1))), TestInfo('())\n', 0, 4, ')', None, ((0, 0), (0, 1), (2, 0), (3, 0))), TestInfo(')(\n', 0, 3, '(', 1, ((0, 0), (1, 0), (1, 1))), # Wrong closers still decrement stack level. TestInfo('{)(]\n', 0, 5, ']', None, ((0, 0), (0, 1), (2, 0), (2, 1), (4, 0))), # Character after backslash. TestInfo(':\\a\n', 0, 4, '\\a', None, ((0, 0),)), TestInfo('\n', 0, 0, '', None, ((0, 0),)), ) for test in tests: with self.subTest(string=test.string): setcode(test.string) study() eq(p.study_level, 2) eq(p.stmt_start, test.start) eq(p.stmt_end, test.end) eq(p.lastch, test.lastch) eq(p.lastopenbracketpos, test.openbracket) eq(p.stmt_bracketing, test.bracketing) # Called again, just returns without reprocessing. self.assertIsNone(study()) def test_get_num_lines_in_stmt(self): eq = self.assertEqual p = self.parser setcode = p.set_code getlines = p.get_num_lines_in_stmt TestInfo = namedtuple('TestInfo', ['string', 'lines']) tests = ( TestInfo('[x for x in a]\n', 1), # Closed on one line. TestInfo('[x\nfor x in a\n', 2), # Not closed. TestInfo('[x\\\nfor x in a\\\n', 2), # "", uneeded backslashes. TestInfo('[x\nfor x in a\n]\n', 3), # Closed on multi-line. TestInfo('\n"""Docstring comment L1"""\nL2\nL3\nL4\n', 1), TestInfo('\n"""Docstring comment L1\nL2"""\nL3\nL4\n', 1), TestInfo('\n"""Docstring comment L1\\\nL2\\\nL3\\\nL4\\\n', 4), TestInfo('\n\n"""Docstring comment L1\\\nL2\\\nL3\\\nL4\\\n"""\n', 5) ) # Blank string doesn't have enough elements in goodlines. setcode('') with self.assertRaises(IndexError): getlines() for test in tests: with self.subTest(string=test.string): setcode(test.string) eq(getlines(), test.lines) def test_compute_bracket_indent(self): eq = self.assertEqual p = self.parser setcode = p.set_code indent = p.compute_bracket_indent TestInfo = namedtuple('TestInfo', ['string', 'spaces']) tests = ( TestInfo('def function1(self, a,\n', 14), # Characters after bracket. TestInfo('\n def function1(self, a,\n', 18), TestInfo('\n\tdef function1(self, a,\n', 18), # No characters after bracket. TestInfo('\n def function1(\n', 8), TestInfo('\n\tdef function1(\n', 8), TestInfo('\n def function1( \n', 8), # Ignore extra spaces. TestInfo('[\n"first item",\n # Comment line\n "next item",\n', 0), TestInfo('[\n "first item",\n # Comment line\n "next item",\n', 2), TestInfo('["first item",\n # Comment line\n "next item",\n', 1), TestInfo('(\n', 4), TestInfo('(a\n', 1), ) # Must be C_BRACKET continuation type. setcode('def function1(self, a, b):\n') with self.assertRaises(AssertionError): indent() for test in tests: setcode(test.string) eq(indent(), test.spaces) def test_compute_backslash_indent(self): eq = self.assertEqual p = self.parser setcode = p.set_code indent = p.compute_backslash_indent # Must be C_BACKSLASH continuation type. errors = (('def function1(self, a, b\\\n'), # Bracket. (' """ (\\\n'), # Docstring. ('a = #\\\n'), # Inline comment. ) for string in errors: with self.subTest(string=string): setcode(string) with self.assertRaises(AssertionError): indent() TestInfo = namedtuple('TestInfo', ('string', 'spaces')) tests = (TestInfo('a = (1 + 2) - 5 *\\\n', 4), TestInfo('a = 1 + 2 - 5 *\\\n', 4), TestInfo(' a = 1 + 2 - 5 *\\\n', 8), TestInfo(' a = "spam"\\\n', 6), TestInfo(' a = \\\n"a"\\\n', 4), TestInfo(' a = #\\\n"a"\\\n', 5), TestInfo('a == \\\n', 2), TestInfo('a != \\\n', 2), # Difference between containing = and those not. TestInfo('\\\n', 2), TestInfo(' \\\n', 6), TestInfo('\t\\\n', 6), TestInfo('a\\\n', 3), TestInfo('{}\\\n', 4), TestInfo('(1 + 2) - 5 *\\\n', 3), ) for test in tests: with self.subTest(string=test.string): setcode(test.string) eq(indent(), test.spaces) def test_get_base_indent_string(self): eq = self.assertEqual p = self.parser setcode = p.set_code baseindent = p.get_base_indent_string TestInfo = namedtuple('TestInfo', ['string', 'indent']) tests = (TestInfo('', ''), TestInfo('def a():\n', ''), TestInfo('\tdef a():\n', '\t'), TestInfo(' def a():\n', ' '), TestInfo(' def a(\n', ' '), TestInfo('\t\n def a(\n', ' '), TestInfo('\t\n # Comment.\n', ' '), ) for test in tests: with self.subTest(string=test.string): setcode(test.string) eq(baseindent(), test.indent) def test_is_block_opener(self): yes = self.assertTrue no = self.assertFalse p = self.parser setcode = p.set_code opener = p.is_block_opener TestInfo = namedtuple('TestInfo', ['string', 'assert_']) tests = ( TestInfo('def a():\n', yes), TestInfo('\n def function1(self, a,\n b):\n', yes), TestInfo(':\n', yes), TestInfo('a:\n', yes), TestInfo('):\n', yes), TestInfo('(:\n', yes), TestInfo('":\n', no), TestInfo('\n def function1(self, a,\n', no), TestInfo('def function1(self, a):\n pass\n', no), TestInfo('# A comment:\n', no), TestInfo('"""A docstring:\n', no), TestInfo('"""A docstring:\n', no), ) for test in tests: with self.subTest(string=test.string): setcode(test.string) test.assert_(opener()) def test_is_block_closer(self): yes = self.assertTrue no = self.assertFalse p = self.parser setcode = p.set_code closer = p.is_block_closer TestInfo = namedtuple('TestInfo', ['string', 'assert_']) tests = ( TestInfo('return\n', yes), TestInfo('\tbreak\n', yes), TestInfo(' continue\n', yes), TestInfo(' raise\n', yes), TestInfo('pass \n', yes), TestInfo('pass\t\n', yes), TestInfo('return #\n', yes), TestInfo('raised\n', no), TestInfo('returning\n', no), TestInfo('# return\n', no), TestInfo('"""break\n', no), TestInfo('"continue\n', no), TestInfo('def function1(self, a):\n pass\n', yes), ) for test in tests: with self.subTest(string=test.string): setcode(test.string) test.assert_(closer()) def test_get_last_stmt_bracketing(self): eq = self.assertEqual p = self.parser setcode = p.set_code bracketing = p.get_last_stmt_bracketing TestInfo = namedtuple('TestInfo', ['string', 'bracket']) tests = ( TestInfo('', ((0, 0),)), TestInfo('a\n', ((0, 0),)), TestInfo('()()\n', ((0, 0), (0, 1), (2, 0), (2, 1), (4, 0))), TestInfo('(\n)()\n', ((0, 0), (0, 1), (3, 0), (3, 1), (5, 0))), TestInfo('()\n()\n', ((3, 0), (3, 1), (5, 0))), TestInfo('()(\n)\n', ((0, 0), (0, 1), (2, 0), (2, 1), (5, 0))), TestInfo('(())\n', ((0, 0), (0, 1), (1, 2), (3, 1), (4, 0))), TestInfo('(\n())\n', ((0, 0), (0, 1), (2, 2), (4, 1), (5, 0))), # Same as matched test. TestInfo('{)(]\n', ((0, 0), (0, 1), (2, 0), (2, 1), (4, 0))), TestInfo('(((())\n', ((0, 0), (0, 1), (1, 2), (2, 3), (3, 4), (5, 3), (6, 2))), ) for test in tests: with self.subTest(string=test.string): setcode(test.string) eq(bracketing(), test.bracket) if __name__ == '__main__': unittest.main(verbosity=2)