1""" 2Test the API of the symtable module. 3""" 4import symtable 5import unittest 6 7 8 9TEST_CODE = """ 10import sys 11 12glob = 42 13some_var = 12 14 15class Mine: 16 instance_var = 24 17 def a_method(p1, p2): 18 pass 19 20def spam(a, b, *var, **kw): 21 global bar 22 bar = 47 23 some_var = 10 24 x = 23 25 glob 26 def internal(): 27 return x 28 def other_internal(): 29 nonlocal some_var 30 some_var = 3 31 return some_var 32 return internal 33 34def foo(): 35 pass 36 37def namespace_test(): pass 38def namespace_test(): pass 39""" 40 41 42def find_block(block, name): 43 for ch in block.get_children(): 44 if ch.get_name() == name: 45 return ch 46 47 48class SymtableTest(unittest.TestCase): 49 50 top = symtable.symtable(TEST_CODE, "?", "exec") 51 # These correspond to scopes in TEST_CODE 52 Mine = find_block(top, "Mine") 53 a_method = find_block(Mine, "a_method") 54 spam = find_block(top, "spam") 55 internal = find_block(spam, "internal") 56 other_internal = find_block(spam, "other_internal") 57 foo = find_block(top, "foo") 58 59 def test_type(self): 60 self.assertEqual(self.top.get_type(), "module") 61 self.assertEqual(self.Mine.get_type(), "class") 62 self.assertEqual(self.a_method.get_type(), "function") 63 self.assertEqual(self.spam.get_type(), "function") 64 self.assertEqual(self.internal.get_type(), "function") 65 66 def test_optimized(self): 67 self.assertFalse(self.top.is_optimized()) 68 self.assertFalse(self.top.has_exec()) 69 70 self.assertTrue(self.spam.is_optimized()) 71 72 def test_nested(self): 73 self.assertFalse(self.top.is_nested()) 74 self.assertFalse(self.Mine.is_nested()) 75 self.assertFalse(self.spam.is_nested()) 76 self.assertTrue(self.internal.is_nested()) 77 78 def test_children(self): 79 self.assertTrue(self.top.has_children()) 80 self.assertTrue(self.Mine.has_children()) 81 self.assertFalse(self.foo.has_children()) 82 83 def test_lineno(self): 84 self.assertEqual(self.top.get_lineno(), 0) 85 self.assertEqual(self.spam.get_lineno(), 12) 86 87 def test_function_info(self): 88 func = self.spam 89 self.assertEqual(sorted(func.get_parameters()), ["a", "b", "kw", "var"]) 90 expected = ['a', 'b', 'internal', 'kw', 'other_internal', 'some_var', 'var', 'x'] 91 self.assertEqual(sorted(func.get_locals()), expected) 92 self.assertEqual(sorted(func.get_globals()), ["bar", "glob"]) 93 self.assertEqual(self.internal.get_frees(), ("x",)) 94 95 def test_globals(self): 96 self.assertTrue(self.spam.lookup("glob").is_global()) 97 self.assertFalse(self.spam.lookup("glob").is_declared_global()) 98 self.assertTrue(self.spam.lookup("bar").is_global()) 99 self.assertTrue(self.spam.lookup("bar").is_declared_global()) 100 self.assertFalse(self.internal.lookup("x").is_global()) 101 self.assertFalse(self.Mine.lookup("instance_var").is_global()) 102 self.assertTrue(self.spam.lookup("bar").is_global()) 103 104 def test_nonlocal(self): 105 self.assertFalse(self.spam.lookup("some_var").is_nonlocal()) 106 self.assertTrue(self.other_internal.lookup("some_var").is_nonlocal()) 107 expected = ("some_var",) 108 self.assertEqual(self.other_internal.get_nonlocals(), expected) 109 110 def test_local(self): 111 self.assertTrue(self.spam.lookup("x").is_local()) 112 self.assertFalse(self.spam.lookup("bar").is_local()) 113 114 def test_free(self): 115 self.assertTrue(self.internal.lookup("x").is_free()) 116 117 def test_referenced(self): 118 self.assertTrue(self.internal.lookup("x").is_referenced()) 119 self.assertTrue(self.spam.lookup("internal").is_referenced()) 120 self.assertFalse(self.spam.lookup("x").is_referenced()) 121 122 def test_parameters(self): 123 for sym in ("a", "var", "kw"): 124 self.assertTrue(self.spam.lookup(sym).is_parameter()) 125 self.assertFalse(self.spam.lookup("x").is_parameter()) 126 127 def test_symbol_lookup(self): 128 self.assertEqual(len(self.top.get_identifiers()), 129 len(self.top.get_symbols())) 130 131 self.assertRaises(KeyError, self.top.lookup, "not_here") 132 133 def test_namespaces(self): 134 self.assertTrue(self.top.lookup("Mine").is_namespace()) 135 self.assertTrue(self.Mine.lookup("a_method").is_namespace()) 136 self.assertTrue(self.top.lookup("spam").is_namespace()) 137 self.assertTrue(self.spam.lookup("internal").is_namespace()) 138 self.assertTrue(self.top.lookup("namespace_test").is_namespace()) 139 self.assertFalse(self.spam.lookup("x").is_namespace()) 140 141 self.assertTrue(self.top.lookup("spam").get_namespace() is self.spam) 142 ns_test = self.top.lookup("namespace_test") 143 self.assertEqual(len(ns_test.get_namespaces()), 2) 144 self.assertRaises(ValueError, ns_test.get_namespace) 145 146 def test_assigned(self): 147 self.assertTrue(self.spam.lookup("x").is_assigned()) 148 self.assertTrue(self.spam.lookup("bar").is_assigned()) 149 self.assertTrue(self.top.lookup("spam").is_assigned()) 150 self.assertTrue(self.Mine.lookup("a_method").is_assigned()) 151 self.assertFalse(self.internal.lookup("x").is_assigned()) 152 153 def test_annotated(self): 154 st1 = symtable.symtable('def f():\n x: int\n', 'test', 'exec') 155 st2 = st1.get_children()[0] 156 self.assertTrue(st2.lookup('x').is_local()) 157 self.assertTrue(st2.lookup('x').is_annotated()) 158 self.assertFalse(st2.lookup('x').is_global()) 159 st3 = symtable.symtable('def f():\n x = 1\n', 'test', 'exec') 160 st4 = st3.get_children()[0] 161 self.assertTrue(st4.lookup('x').is_local()) 162 self.assertFalse(st4.lookup('x').is_annotated()) 163 164 # Test that annotations in the global scope are valid after the 165 # variable is declared as nonlocal. 166 st5 = symtable.symtable('global x\nx: int', 'test', 'exec') 167 self.assertTrue(st5.lookup("x").is_global()) 168 169 # Test that annotations for nonlocals are valid after the 170 # variable is declared as nonlocal. 171 st6 = symtable.symtable('def g():\n' 172 ' x = 2\n' 173 ' def f():\n' 174 ' nonlocal x\n' 175 ' x: int', 176 'test', 'exec') 177 178 def test_imported(self): 179 self.assertTrue(self.top.lookup("sys").is_imported()) 180 181 def test_name(self): 182 self.assertEqual(self.top.get_name(), "top") 183 self.assertEqual(self.spam.get_name(), "spam") 184 self.assertEqual(self.spam.lookup("x").get_name(), "x") 185 self.assertEqual(self.Mine.get_name(), "Mine") 186 187 def test_class_info(self): 188 self.assertEqual(self.Mine.get_methods(), ('a_method',)) 189 190 def test_filename_correct(self): 191 ### Bug tickler: SyntaxError file name correct whether error raised 192 ### while parsing or building symbol table. 193 def checkfilename(brokencode, offset): 194 try: 195 symtable.symtable(brokencode, "spam", "exec") 196 except SyntaxError as e: 197 self.assertEqual(e.filename, "spam") 198 self.assertEqual(e.lineno, 1) 199 self.assertEqual(e.offset, offset) 200 else: 201 self.fail("no SyntaxError for %r" % (brokencode,)) 202 checkfilename("def f(x): foo)(", 14) # parse-time 203 checkfilename("def f(x): global x", 11) # symtable-build-time 204 symtable.symtable("pass", b"spam", "exec") 205 with self.assertWarns(DeprecationWarning), \ 206 self.assertRaises(TypeError): 207 symtable.symtable("pass", bytearray(b"spam"), "exec") 208 with self.assertWarns(DeprecationWarning): 209 symtable.symtable("pass", memoryview(b"spam"), "exec") 210 with self.assertRaises(TypeError): 211 symtable.symtable("pass", list(b"spam"), "exec") 212 213 def test_eval(self): 214 symbols = symtable.symtable("42", "?", "eval") 215 216 def test_single(self): 217 symbols = symtable.symtable("42", "?", "single") 218 219 def test_exec(self): 220 symbols = symtable.symtable("def f(x): return x", "?", "exec") 221 222 def test_bytes(self): 223 top = symtable.symtable(TEST_CODE.encode('utf8'), "?", "exec") 224 self.assertIsNotNone(find_block(top, "Mine")) 225 226 code = b'# -*- coding: iso8859-15 -*-\nclass \xb4: pass\n' 227 228 top = symtable.symtable(code, "?", "exec") 229 self.assertIsNotNone(find_block(top, "\u017d")) 230 231 232if __name__ == '__main__': 233 unittest.main() 234