1"Test hyperparser, coverage 98%." 2 3from idlelib.hyperparser import HyperParser 4import unittest 5from test.support import requires 6from tkinter import Tk, Text 7from idlelib.editor import EditorWindow 8 9class DummyEditwin: 10 def __init__(self, text): 11 self.text = text 12 self.indentwidth = 8 13 self.tabwidth = 8 14 self.prompt_last_line = '>>>' 15 self.num_context_lines = 50, 500, 1000 16 17 _build_char_in_string_func = EditorWindow._build_char_in_string_func 18 is_char_in_string = EditorWindow.is_char_in_string 19 20 21class HyperParserTest(unittest.TestCase): 22 code = ( 23 '"""This is a module docstring"""\n' 24 '# this line is a comment\n' 25 'x = "this is a string"\n' 26 "y = 'this is also a string'\n" 27 'l = [i for i in range(10)]\n' 28 'm = [py*py for # comment\n' 29 ' py in l]\n' 30 'x.__len__\n' 31 "z = ((r'asdf')+('a')))\n" 32 '[x for x in\n' 33 'for = False\n' 34 'cliché = "this is a string with unicode, what a cliché"' 35 ) 36 37 @classmethod 38 def setUpClass(cls): 39 requires('gui') 40 cls.root = Tk() 41 cls.root.withdraw() 42 cls.text = Text(cls.root) 43 cls.editwin = DummyEditwin(cls.text) 44 45 @classmethod 46 def tearDownClass(cls): 47 del cls.text, cls.editwin 48 cls.root.destroy() 49 del cls.root 50 51 def setUp(self): 52 self.text.insert('insert', self.code) 53 54 def tearDown(self): 55 self.text.delete('1.0', 'end') 56 self.editwin.prompt_last_line = '>>>' 57 58 def get_parser(self, index): 59 """ 60 Return a parser object with index at 'index' 61 """ 62 return HyperParser(self.editwin, index) 63 64 def test_init(self): 65 """ 66 test corner cases in the init method 67 """ 68 with self.assertRaises(ValueError) as ve: 69 self.text.tag_add('console', '1.0', '1.end') 70 p = self.get_parser('1.5') 71 self.assertIn('precedes', str(ve.exception)) 72 73 # test without ps1 74 self.editwin.prompt_last_line = '' 75 76 # number of lines lesser than 50 77 p = self.get_parser('end') 78 self.assertEqual(p.rawtext, self.text.get('1.0', 'end')) 79 80 # number of lines greater than 50 81 self.text.insert('end', self.text.get('1.0', 'end')*4) 82 p = self.get_parser('54.5') 83 84 def test_is_in_string(self): 85 get = self.get_parser 86 87 p = get('1.0') 88 self.assertFalse(p.is_in_string()) 89 p = get('1.4') 90 self.assertTrue(p.is_in_string()) 91 p = get('2.3') 92 self.assertFalse(p.is_in_string()) 93 p = get('3.3') 94 self.assertFalse(p.is_in_string()) 95 p = get('3.7') 96 self.assertTrue(p.is_in_string()) 97 p = get('4.6') 98 self.assertTrue(p.is_in_string()) 99 p = get('12.54') 100 self.assertTrue(p.is_in_string()) 101 102 def test_is_in_code(self): 103 get = self.get_parser 104 105 p = get('1.0') 106 self.assertTrue(p.is_in_code()) 107 p = get('1.1') 108 self.assertFalse(p.is_in_code()) 109 p = get('2.5') 110 self.assertFalse(p.is_in_code()) 111 p = get('3.4') 112 self.assertTrue(p.is_in_code()) 113 p = get('3.6') 114 self.assertFalse(p.is_in_code()) 115 p = get('4.14') 116 self.assertFalse(p.is_in_code()) 117 118 def test_get_surrounding_bracket(self): 119 get = self.get_parser 120 121 def without_mustclose(parser): 122 # a utility function to get surrounding bracket 123 # with mustclose=False 124 return parser.get_surrounding_brackets(mustclose=False) 125 126 def with_mustclose(parser): 127 # a utility function to get surrounding bracket 128 # with mustclose=True 129 return parser.get_surrounding_brackets(mustclose=True) 130 131 p = get('3.2') 132 self.assertIsNone(with_mustclose(p)) 133 self.assertIsNone(without_mustclose(p)) 134 135 p = get('5.6') 136 self.assertTupleEqual(without_mustclose(p), ('5.4', '5.25')) 137 self.assertTupleEqual(without_mustclose(p), with_mustclose(p)) 138 139 p = get('5.23') 140 self.assertTupleEqual(without_mustclose(p), ('5.21', '5.24')) 141 self.assertTupleEqual(without_mustclose(p), with_mustclose(p)) 142 143 p = get('6.15') 144 self.assertTupleEqual(without_mustclose(p), ('6.4', '6.end')) 145 self.assertIsNone(with_mustclose(p)) 146 147 p = get('9.end') 148 self.assertIsNone(with_mustclose(p)) 149 self.assertIsNone(without_mustclose(p)) 150 151 def test_get_expression(self): 152 get = self.get_parser 153 154 p = get('4.2') 155 self.assertEqual(p.get_expression(), 'y ') 156 157 p = get('4.7') 158 with self.assertRaises(ValueError) as ve: 159 p.get_expression() 160 self.assertIn('is inside a code', str(ve.exception)) 161 162 p = get('5.25') 163 self.assertEqual(p.get_expression(), 'range(10)') 164 165 p = get('6.7') 166 self.assertEqual(p.get_expression(), 'py') 167 168 p = get('6.8') 169 self.assertEqual(p.get_expression(), '') 170 171 p = get('7.9') 172 self.assertEqual(p.get_expression(), 'py') 173 174 p = get('8.end') 175 self.assertEqual(p.get_expression(), 'x.__len__') 176 177 p = get('9.13') 178 self.assertEqual(p.get_expression(), "r'asdf'") 179 180 p = get('9.17') 181 with self.assertRaises(ValueError) as ve: 182 p.get_expression() 183 self.assertIn('is inside a code', str(ve.exception)) 184 185 p = get('10.0') 186 self.assertEqual(p.get_expression(), '') 187 188 p = get('10.6') 189 self.assertEqual(p.get_expression(), '') 190 191 p = get('10.11') 192 self.assertEqual(p.get_expression(), '') 193 194 p = get('11.3') 195 self.assertEqual(p.get_expression(), '') 196 197 p = get('11.11') 198 self.assertEqual(p.get_expression(), 'False') 199 200 p = get('12.6') 201 self.assertEqual(p.get_expression(), 'cliché') 202 203 def test_eat_identifier(self): 204 def is_valid_id(candidate): 205 result = HyperParser._eat_identifier(candidate, 0, len(candidate)) 206 if result == len(candidate): 207 return True 208 elif result == 0: 209 return False 210 else: 211 err_msg = "Unexpected result: {} (expected 0 or {}".format( 212 result, len(candidate) 213 ) 214 raise Exception(err_msg) 215 216 # invalid first character which is valid elsewhere in an identifier 217 self.assertFalse(is_valid_id('2notid')) 218 219 # ASCII-only valid identifiers 220 self.assertTrue(is_valid_id('valid_id')) 221 self.assertTrue(is_valid_id('_valid_id')) 222 self.assertTrue(is_valid_id('valid_id_')) 223 self.assertTrue(is_valid_id('_2valid_id')) 224 225 # keywords which should be "eaten" 226 self.assertTrue(is_valid_id('True')) 227 self.assertTrue(is_valid_id('False')) 228 self.assertTrue(is_valid_id('None')) 229 230 # keywords which should not be "eaten" 231 self.assertFalse(is_valid_id('for')) 232 self.assertFalse(is_valid_id('import')) 233 self.assertFalse(is_valid_id('return')) 234 235 # valid unicode identifiers 236 self.assertTrue(is_valid_id('cliche')) 237 self.assertTrue(is_valid_id('cliché')) 238 self.assertTrue(is_valid_id('a٢')) 239 240 # invalid unicode identifiers 241 self.assertFalse(is_valid_id('2a')) 242 self.assertFalse(is_valid_id('٢a')) 243 self.assertFalse(is_valid_id('a²')) 244 245 # valid identifier after "punctuation" 246 self.assertEqual(HyperParser._eat_identifier('+ var', 0, 5), len('var')) 247 self.assertEqual(HyperParser._eat_identifier('+var', 0, 4), len('var')) 248 self.assertEqual(HyperParser._eat_identifier('.var', 0, 4), len('var')) 249 250 # invalid identifiers 251 self.assertFalse(is_valid_id('+')) 252 self.assertFalse(is_valid_id(' ')) 253 self.assertFalse(is_valid_id(':')) 254 self.assertFalse(is_valid_id('?')) 255 self.assertFalse(is_valid_id('^')) 256 self.assertFalse(is_valid_id('\\')) 257 self.assertFalse(is_valid_id('"')) 258 self.assertFalse(is_valid_id('"a string"')) 259 260 def test_eat_identifier_various_lengths(self): 261 eat_id = HyperParser._eat_identifier 262 263 for length in range(1, 21): 264 self.assertEqual(eat_id('a' * length, 0, length), length) 265 self.assertEqual(eat_id('é' * length, 0, length), length) 266 self.assertEqual(eat_id('a' + '2' * (length - 1), 0, length), length) 267 self.assertEqual(eat_id('é' + '2' * (length - 1), 0, length), length) 268 self.assertEqual(eat_id('é' + 'a' * (length - 1), 0, length), length) 269 self.assertEqual(eat_id('é' * (length - 1) + 'a', 0, length), length) 270 self.assertEqual(eat_id('+' * length, 0, length), 0) 271 self.assertEqual(eat_id('2' + 'a' * (length - 1), 0, length), 0) 272 self.assertEqual(eat_id('2' + 'é' * (length - 1), 0, length), 0) 273 274 275if __name__ == '__main__': 276 unittest.main(verbosity=2) 277