home *** CD-ROM | disk | FTP | other *** search
/ Maximum CD 2011 July / maximum-cd-2011-07.iso / DiscContents / LibO_3.3.2_Win_x86_install_multi.exe / libreoffice1.cab / test_symtable.py < prev    next >
Encoding:
Python Source  |  2011-03-15  |  6.8 KB  |  201 lines
  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()
  201.