AppPkg/Applications/Python: Add Python 2.7.2 sources since the release of Python 2.7.3 made them unavailable from the python.org web site.

These files are a subset of the python-2.7.2.tgz distribution from python.org.  Changed files from PyMod-2.7.2 have been copied into the corresponding directories of this tree, replacing the original files in the distribution.

Signed-off-by: daryl.mcdaniel@intel.com


git-svn-id: https://edk2.svn.sourceforge.net/svnroot/edk2/trunk/edk2@13197 6f19259b-4bc3-4df7-8a09-765794883524

1 files changed, 184 insertions, 0 deletions

diff --git a/AppPkg/Applications/Python/Python-2.7.2/Lib/test/test_symtable.py b/AppPkg/Applications/Python/Python-2.7.2/Lib/test/test_symtable.py
new file mode 100644
index 0000000000..92941799fe
--- /dev/null
+++ b/AppPkg/Applications/Python/Python-2.7.2/Lib/test/test_symtable.py
@@ -0,0 +1,184 @@
+"""

+Test the API of the symtable module.

+"""

+import symtable

+import unittest

+

+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 test_support.check_warnings(

+            ("import \* only allowed at module level", 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_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", "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.assertFalse(self.spam.lookup("glob").is_declared_global())

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

+        self.assertTrue(self.spam.lookup("bar").is_declared_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.assertTrue(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()