1 """

     2 Test the API of the symtable module.

     3 """

     4 import symtable

     5 import unittest

     6 import warnings

     7 

     8 from test import test_support

     9 

    10 

    11 TEST_CODE = """

    12 import sys

    13 

    14 glob = 42

    15 

    16 class Mine:

    17     instance_var = 24

    18     def a_method(p1, p2):

    19         pass

    20 

    21 def spam(a, b, *var, **kw):

    22     global bar

    23     bar = 47

    24     x = 23

    25     glob

    26     def internal():

    27         return x

    28     return internal

    29 

    30 def foo():

    31     exec 'm'

    32     from sys import *

    33 

    34 def namespace_test(): pass

    35 def namespace_test(): pass

    36 """

    37 

    38 

    39 def find_block(block, name):

    40     for ch in block.get_children():

    41         if ch.get_name() == name:

    42             return ch

    43 

    44 

    45 class SymtableTest(unittest.TestCase):

    46 

    47     with warnings.catch_warnings():

    48         # Ignore warnings about "from blank import *"

    49         warnings.simplefilter("ignore", SyntaxWarning)

    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     foo = find_block(top, "foo")

    57 

    58     def test_noops(self):

    59         # Check methods that don't work. They should warn and return False.

    60         def check(w, msg):

    61             self.assertEqual(str(w.message), msg)

    62         sym = self.top.lookup("glob")

    63         with test_support.check_warnings() as w:

    64             warnings.simplefilter("always", DeprecationWarning)

    65             self.assertFalse(sym.is_vararg())

    66             check(w, "is_vararg() is obsolete and will be removed")

    67             w.reset()

    68             self.assertFalse(sym.is_keywordarg())

    69             check(w, "is_keywordarg() is obsolete and will be removed")

    70             w.reset()

    71             self.assertFalse(sym.is_in_tuple())

    72             check(w, "is_in_tuple() is obsolete and will be removed")

    73 

    74     def test_type(self):

    75         self.assertEqual(self.top.get_type(), "module")

    76         self.assertEqual(self.Mine.get_type(), "class")

    77         self.assertEqual(self.a_method.get_type(), "function")

    78         self.assertEqual(self.spam.get_type(), "function")

    79         self.assertEqual(self.internal.get_type(), "function")

    80 

    81     def test_optimized(self):

    82         self.assertFalse(self.top.is_optimized())

    83         self.assertFalse(self.top.has_exec())

    84         self.assertFalse(self.top.has_import_star())

    85 

    86         self.assertTrue(self.spam.is_optimized())

    87 

    88         self.assertFalse(self.foo.is_optimized())

    89         self.assertTrue(self.foo.has_exec())

    90         self.assertTrue(self.foo.has_import_star())

    91 

    92     def test_nested(self):

    93         self.assertFalse(self.top.is_nested())

    94         self.assertFalse(self.Mine.is_nested())

    95         self.assertFalse(self.spam.is_nested())

    96         self.assertTrue(self.internal.is_nested())

    97 

    98     def test_children(self):

    99         self.assertTrue(self.top.has_children())

   100         self.assertTrue(self.Mine.has_children())

   101         self.assertFalse(self.foo.has_children())

   102 

   103     def test_lineno(self):

   104         self.assertEqual(self.top.get_lineno(), 0)

   105         self.assertEqual(self.spam.get_lineno(), 11)

   106 

   107     def test_function_info(self):

   108         func = self.spam

   109         self.assertEqual(func.get_parameters(), ("a", "b", "kw", "var"))

   110         self.assertEqual(func.get_locals(),

   111                          ("a", "b", "bar", "internal", "kw", "var", "x"))

   112         self.assertEqual(func.get_globals(), ("bar", "glob"))

   113         self.assertEqual(self.internal.get_frees(), ("x",))

   114 

   115     def test_globals(self):

   116         self.assertTrue(self.spam.lookup("glob").is_global())

   117         self.assertTrue(self.spam.lookup("bar").is_global())

   118         self.assertFalse(self.internal.lookup("x").is_global())

   119         self.assertFalse(self.Mine.lookup("instance_var").is_global())

   120 

   121     def test_local(self):

   122         self.assertTrue(self.spam.lookup("x").is_local())

   123         self.assertFalse(self.internal.lookup("x").is_local())

   124 

   125     def test_referenced(self):

   126         self.assertTrue(self.internal.lookup("x").is_referenced())

   127         self.assertTrue(self.spam.lookup("internal").is_referenced())

   128         self.assertFalse(self.spam.lookup("x").is_referenced())

   129 

   130     def test_parameters(self):

   131         for sym in ("a", "var", "kw"):

   132             self.assertTrue(self.spam.lookup(sym).is_parameter())

   133         self.assertFalse(self.spam.lookup("x").is_parameter())

   134 

   135     def test_symbol_lookup(self):

   136         self.assertEqual(len(self.top.get_identifiers()),

   137                          len(self.top.get_symbols()))

   138 

   139         self.assertRaises(KeyError, self.top.lookup, "not_here")

   140 

   141     def test_namespaces(self):

   142         self.assertTrue(self.top.lookup("Mine").is_namespace())

   143         self.assertTrue(self.Mine.lookup("a_method").is_namespace())

   144         self.assertTrue(self.top.lookup("spam").is_namespace())

   145         self.assertTrue(self.spam.lookup("internal").is_namespace())

   146         self.assertTrue(self.top.lookup("namespace_test").is_namespace())

   147         self.assertFalse(self.spam.lookup("x").is_namespace())

   148 

   149         self.assert_(self.top.lookup("spam").get_namespace() is self.spam)

   150         ns_test = self.top.lookup("namespace_test")

   151         self.assertEqual(len(ns_test.get_namespaces()), 2)

   152         self.assertRaises(ValueError, ns_test.get_namespace)

   153 

   154     def test_assigned(self):

   155         self.assertTrue(self.spam.lookup("x").is_assigned())

   156         self.assertTrue(self.spam.lookup("bar").is_assigned())

   157         self.assertTrue(self.top.lookup("spam").is_assigned())

   158         self.assertTrue(self.Mine.lookup("a_method").is_assigned())

   159         self.assertFalse(self.internal.lookup("x").is_assigned())

   160 

   161     def test_imported(self):

   162         self.assertTrue(self.top.lookup("sys").is_imported())

   163 

   164     def test_name(self):

   165         self.assertEqual(self.top.get_name(), "top")

   166         self.assertEqual(self.spam.get_name(), "spam")

   167         self.assertEqual(self.spam.lookup("x").get_name(), "x")

   168         self.assertEqual(self.Mine.get_name(), "Mine")

   169 

   170     def test_class_info(self):

   171         self.assertEqual(self.Mine.get_methods(), ('a_method',))

   172 

   173     def test_filename_correct(self):

   174         ### Bug tickler: SyntaxError file name correct whether error raised

   175         ### while parsing or building symbol table.

   176         def checkfilename(brokencode):

   177             try:

   178                 symtable.symtable(brokencode, "spam", "exec")

   179             except SyntaxError as e:

   180                 self.assertEqual(e.filename, "spam")

   181             else:

   182                 self.fail("no SyntaxError for %r" % (brokencode,))

   183         checkfilename("def f(x): foo)(")  # parse-time

   184         checkfilename("def f(x): global x")  # symtable-build-time

   185 

   186     def test_eval(self):

   187         symbols = symtable.symtable("42", "?", "eval")

   188 

   189     def test_single(self):

   190         symbols = symtable.symtable("42", "?", "single")

   191 

   192     def test_exec(self):

   193         symbols = symtable.symtable("def f(x): return x", "?", "exec")

   194 

   195 

   196 def test_main():

   197     test_support.run_unittest(SymtableTest)

   198 

   199 if __name__ == '__main__':

   200     test_main()