--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/symbian-qemu-0.9.1-12/python-2.6.1/Lib/test/test_symtable.py Fri Jul 31 15:01:17 2009 +0100
@@ -0,0 +1,200 @@
+"""
+Test the API of the symtable module.
+"""
+import symtable
+import unittest
+import warnings
+
+from test import test_support
+
+
+TEST_CODE = """
+import sys
+
+glob = 42
+
+class Mine:
+ instance_var = 24
+ def a_method(p1, p2):
+ pass
+
+def spam(a, b, *var, **kw):
+ global bar
+ bar = 47
+ x = 23
+ glob
+ def internal():
+ return x
+ return internal
+
+def foo():
+ exec 'm'
+ from sys import *
+
+def namespace_test(): pass
+def namespace_test(): pass
+"""
+
+
+def find_block(block, name):
+ for ch in block.get_children():
+ if ch.get_name() == name:
+ return ch
+
+
+class SymtableTest(unittest.TestCase):
+
+ with warnings.catch_warnings():
+ # Ignore warnings about "from blank import *"
+ warnings.simplefilter("ignore", SyntaxWarning)
+ top = symtable.symtable(TEST_CODE, "?", "exec")
+ # These correspond to scopes in TEST_CODE
+ Mine = find_block(top, "Mine")
+ a_method = find_block(Mine, "a_method")
+ spam = find_block(top, "spam")
+ internal = find_block(spam, "internal")
+ foo = find_block(top, "foo")
+
+ def test_noops(self):
+ # Check methods that don't work. They should warn and return False.
+ def check(w, msg):
+ self.assertEqual(str(w.message), msg)
+ sym = self.top.lookup("glob")
+ with test_support.check_warnings() as w:
+ warnings.simplefilter("always", DeprecationWarning)
+ self.assertFalse(sym.is_vararg())
+ check(w, "is_vararg() is obsolete and will be removed")
+ w.reset()
+ self.assertFalse(sym.is_keywordarg())
+ check(w, "is_keywordarg() is obsolete and will be removed")
+ w.reset()
+ self.assertFalse(sym.is_in_tuple())
+ check(w, "is_in_tuple() is obsolete and will be removed")
+
+ def test_type(self):
+ self.assertEqual(self.top.get_type(), "module")
+ self.assertEqual(self.Mine.get_type(), "class")
+ self.assertEqual(self.a_method.get_type(), "function")
+ self.assertEqual(self.spam.get_type(), "function")
+ self.assertEqual(self.internal.get_type(), "function")
+
+ def test_optimized(self):
+ self.assertFalse(self.top.is_optimized())
+ self.assertFalse(self.top.has_exec())
+ self.assertFalse(self.top.has_import_star())
+
+ self.assertTrue(self.spam.is_optimized())
+
+ self.assertFalse(self.foo.is_optimized())
+ self.assertTrue(self.foo.has_exec())
+ self.assertTrue(self.foo.has_import_star())
+
+ def test_nested(self):
+ self.assertFalse(self.top.is_nested())
+ self.assertFalse(self.Mine.is_nested())
+ self.assertFalse(self.spam.is_nested())
+ self.assertTrue(self.internal.is_nested())
+
+ def test_children(self):
+ self.assertTrue(self.top.has_children())
+ self.assertTrue(self.Mine.has_children())
+ self.assertFalse(self.foo.has_children())
+
+ def test_lineno(self):
+ self.assertEqual(self.top.get_lineno(), 0)
+ self.assertEqual(self.spam.get_lineno(), 11)
+
+ def test_function_info(self):
+ func = self.spam
+ self.assertEqual(func.get_parameters(), ("a", "b", "kw", "var"))
+ self.assertEqual(func.get_locals(),
+ ("a", "b", "bar", "internal", "kw", "var", "x"))
+ self.assertEqual(func.get_globals(), ("bar", "glob"))
+ self.assertEqual(self.internal.get_frees(), ("x",))
+
+ def test_globals(self):
+ self.assertTrue(self.spam.lookup("glob").is_global())
+ self.assertTrue(self.spam.lookup("bar").is_global())
+ self.assertFalse(self.internal.lookup("x").is_global())
+ self.assertFalse(self.Mine.lookup("instance_var").is_global())
+
+ def test_local(self):
+ self.assertTrue(self.spam.lookup("x").is_local())
+ self.assertFalse(self.internal.lookup("x").is_local())
+
+ def test_referenced(self):
+ self.assertTrue(self.internal.lookup("x").is_referenced())
+ self.assertTrue(self.spam.lookup("internal").is_referenced())
+ self.assertFalse(self.spam.lookup("x").is_referenced())
+
+ def test_parameters(self):
+ for sym in ("a", "var", "kw"):
+ self.assertTrue(self.spam.lookup(sym).is_parameter())
+ self.assertFalse(self.spam.lookup("x").is_parameter())
+
+ def test_symbol_lookup(self):
+ self.assertEqual(len(self.top.get_identifiers()),
+ len(self.top.get_symbols()))
+
+ self.assertRaises(KeyError, self.top.lookup, "not_here")
+
+ def test_namespaces(self):
+ self.assertTrue(self.top.lookup("Mine").is_namespace())
+ self.assertTrue(self.Mine.lookup("a_method").is_namespace())
+ self.assertTrue(self.top.lookup("spam").is_namespace())
+ self.assertTrue(self.spam.lookup("internal").is_namespace())
+ self.assertTrue(self.top.lookup("namespace_test").is_namespace())
+ self.assertFalse(self.spam.lookup("x").is_namespace())
+
+ self.assert_(self.top.lookup("spam").get_namespace() is self.spam)
+ ns_test = self.top.lookup("namespace_test")
+ self.assertEqual(len(ns_test.get_namespaces()), 2)
+ self.assertRaises(ValueError, ns_test.get_namespace)
+
+ def test_assigned(self):
+ self.assertTrue(self.spam.lookup("x").is_assigned())
+ self.assertTrue(self.spam.lookup("bar").is_assigned())
+ self.assertTrue(self.top.lookup("spam").is_assigned())
+ self.assertTrue(self.Mine.lookup("a_method").is_assigned())
+ self.assertFalse(self.internal.lookup("x").is_assigned())
+
+ def test_imported(self):
+ self.assertTrue(self.top.lookup("sys").is_imported())
+
+ def test_name(self):
+ self.assertEqual(self.top.get_name(), "top")
+ self.assertEqual(self.spam.get_name(), "spam")
+ self.assertEqual(self.spam.lookup("x").get_name(), "x")
+ self.assertEqual(self.Mine.get_name(), "Mine")
+
+ def test_class_info(self):
+ self.assertEqual(self.Mine.get_methods(), ('a_method',))
+
+ def test_filename_correct(self):
+ ### Bug tickler: SyntaxError file name correct whether error raised
+ ### while parsing or building symbol table.
+ def checkfilename(brokencode):
+ try:
+ symtable.symtable(brokencode, "spam", "exec")
+ except SyntaxError as e:
+ self.assertEqual(e.filename, "spam")
+ else:
+ self.fail("no SyntaxError for %r" % (brokencode,))
+ checkfilename("def f(x): foo)(") # parse-time
+ checkfilename("def f(x): global x") # symtable-build-time
+
+ def test_eval(self):
+ symbols = symtable.symtable("42", "?", "eval")
+
+ def test_single(self):
+ symbols = symtable.symtable("42", "?", "single")
+
+ def test_exec(self):
+ symbols = symtable.symtable("def f(x): return x", "?", "exec")
+
+
+def test_main():
+ test_support.run_unittest(SymtableTest)
+
+if __name__ == '__main__':
+ test_main()