From 4710c53dcad1ebf3755f3efb9e80ac24bd72a9b2 Mon Sep 17 00:00:00 2001
From: darylm503 <darylm503@6f19259b-4bc3-4df7-8a09-765794883524>
Date: Mon, 16 Apr 2012 22:12:42 +0000
Subject: 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
---
 .../Python/Python-2.7.2/Lib/test/test_cpickle.py   | 139 +++++++++++++++++++++
 1 file changed, 139 insertions(+)
 create mode 100644 AppPkg/Applications/Python/Python-2.7.2/Lib/test/test_cpickle.py

(limited to 'AppPkg/Applications/Python/Python-2.7.2/Lib/test/test_cpickle.py')

diff --git a/AppPkg/Applications/Python/Python-2.7.2/Lib/test/test_cpickle.py b/AppPkg/Applications/Python/Python-2.7.2/Lib/test/test_cpickle.py
new file mode 100644
index 0000000000..4e34874322
--- /dev/null
+++ b/AppPkg/Applications/Python/Python-2.7.2/Lib/test/test_cpickle.py
@@ -0,0 +1,139 @@
+import cPickle, unittest
+from cStringIO import StringIO
+from test.pickletester import AbstractPickleTests, AbstractPickleModuleTests
+from test.pickletester import AbstractPicklerUnpicklerObjectTests
+from test import test_support
+
+class cPickleTests(AbstractPickleTests, AbstractPickleModuleTests):
+
+    def setUp(self):
+        self.dumps = cPickle.dumps
+        self.loads = cPickle.loads
+
+    error = cPickle.BadPickleGet
+    module = cPickle
+
+class cPicklePicklerTests(AbstractPickleTests):
+
+    def dumps(self, arg, proto=0):
+        f = StringIO()
+        p = cPickle.Pickler(f, proto)
+        p.dump(arg)
+        f.seek(0)
+        return f.read()
+
+    def loads(self, buf):
+        f = StringIO(buf)
+        p = cPickle.Unpickler(f)
+        return p.load()
+
+    error = cPickle.BadPickleGet
+
+class cPickleListPicklerTests(AbstractPickleTests):
+
+    def dumps(self, arg, proto=0):
+        p = cPickle.Pickler(proto)
+        p.dump(arg)
+        return p.getvalue()
+
+    def loads(self, *args):
+        f = StringIO(args[0])
+        p = cPickle.Unpickler(f)
+        return p.load()
+
+    error = cPickle.BadPickleGet
+
+class cPickleFastPicklerTests(AbstractPickleTests):
+
+    def dumps(self, arg, proto=0):
+        f = StringIO()
+        p = cPickle.Pickler(f, proto)
+        p.fast = 1
+        p.dump(arg)
+        f.seek(0)
+        return f.read()
+
+    def loads(self, *args):
+        f = StringIO(args[0])
+        p = cPickle.Unpickler(f)
+        return p.load()
+
+    error = cPickle.BadPickleGet
+
+    def test_recursive_list(self):
+        self.assertRaises(ValueError,
+                          AbstractPickleTests.test_recursive_list,
+                          self)
+
+    def test_recursive_tuple(self):
+        self.assertRaises(ValueError,
+                          AbstractPickleTests.test_recursive_tuple,
+                          self)
+
+    def test_recursive_inst(self):
+        self.assertRaises(ValueError,
+                          AbstractPickleTests.test_recursive_inst,
+                          self)
+
+    def test_recursive_dict(self):
+        self.assertRaises(ValueError,
+                          AbstractPickleTests.test_recursive_dict,
+                          self)
+
+    def test_recursive_multi(self):
+        self.assertRaises(ValueError,
+                          AbstractPickleTests.test_recursive_multi,
+                          self)
+
+    def test_nonrecursive_deep(self):
+        # If it's not cyclic, it should pickle OK even if the nesting
+        # depth exceeds PY_CPICKLE_FAST_LIMIT.  That happens to be
+        # 50 today.  Jack Jansen reported stack overflow on Mac OS 9
+        # at 64.
+        a = []
+        for i in range(60):
+            a = [a]
+        b = self.loads(self.dumps(a))
+        self.assertEqual(a, b)
+
+class cPicklePicklerUnpicklerObjectTests(AbstractPicklerUnpicklerObjectTests):
+
+    pickler_class = cPickle.Pickler
+    unpickler_class = cPickle.Unpickler
+
+
+class Node(object):
+    pass
+
+class cPickleDeepRecursive(unittest.TestCase):
+    def test_issue2702(self):
+        # This should raise a RecursionLimit but in some
+        # platforms (FreeBSD, win32) sometimes raises KeyError instead,
+        # or just silently terminates the interpreter (=crashes).
+        nodes = [Node() for i in range(500)]
+        for n in nodes:
+            n.connections = list(nodes)
+            n.connections.remove(n)
+        self.assertRaises((AttributeError, RuntimeError), cPickle.dumps, n)
+
+    def test_issue3179(self):
+        # Safe test, because I broke this case when fixing the
+        # behaviour for the previous test.
+        res=[]
+        for x in range(1,2000):
+            res.append(dict(doc=x, similar=[]))
+        cPickle.dumps(res)
+
+
+def test_main():
+    test_support.run_unittest(
+        cPickleTests,
+        cPicklePicklerTests,
+        cPickleListPicklerTests,
+        cPickleFastPicklerTests,
+        cPickleDeepRecursive,
+        cPicklePicklerUnpicklerObjectTests,
+    )
+
+if __name__ == "__main__":
+    test_main()
-- 
cgit v1.2.3