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, 319 insertions, 0 deletions

diff --git a/AppPkg/Applications/Python/Python-2.7.2/Lib/test/test_extcall.py b/AppPkg/Applications/Python/Python-2.7.2/Lib/test/test_extcall.py
new file mode 100644
index 0000000000..20610b0830
--- /dev/null
+++ b/AppPkg/Applications/Python/Python-2.7.2/Lib/test/test_extcall.py
@@ -0,0 +1,319 @@
+# -*- coding: utf-8 -*-

+

+"""Doctest for method/function calls.

+

+We're going the use these types for extra testing

+

+    >>> from UserList import UserList

+    >>> from UserDict import UserDict

+

+We're defining four helper functions

+

+    >>> def e(a,b):

+    ...     print a, b

+

+    >>> def f(*a, **k):

+    ...     print a, test_support.sortdict(k)

+

+    >>> def g(x, *y, **z):

+    ...     print x, y, test_support.sortdict(z)

+

+    >>> def h(j=1, a=2, h=3):

+    ...     print j, a, h

+

+Argument list examples

+

+    >>> f()

+    () {}

+    >>> f(1)

+    (1,) {}

+    >>> f(1, 2)

+    (1, 2) {}

+    >>> f(1, 2, 3)

+    (1, 2, 3) {}

+    >>> f(1, 2, 3, *(4, 5))

+    (1, 2, 3, 4, 5) {}

+    >>> f(1, 2, 3, *[4, 5])

+    (1, 2, 3, 4, 5) {}

+    >>> f(1, 2, 3, *UserList([4, 5]))

+    (1, 2, 3, 4, 5) {}

+

+Here we add keyword arguments

+

+    >>> f(1, 2, 3, **{'a':4, 'b':5})

+    (1, 2, 3) {'a': 4, 'b': 5}

+    >>> f(1, 2, 3, *[4, 5], **{'a':6, 'b':7})

+    (1, 2, 3, 4, 5) {'a': 6, 'b': 7}

+    >>> f(1, 2, 3, x=4, y=5, *(6, 7), **{'a':8, 'b': 9})

+    (1, 2, 3, 6, 7) {'a': 8, 'b': 9, 'x': 4, 'y': 5}

+

+    >>> f(1, 2, 3, **UserDict(a=4, b=5))

+    (1, 2, 3) {'a': 4, 'b': 5}

+    >>> f(1, 2, 3, *(4, 5), **UserDict(a=6, b=7))

+    (1, 2, 3, 4, 5) {'a': 6, 'b': 7}

+    >>> f(1, 2, 3, x=4, y=5, *(6, 7), **UserDict(a=8, b=9))

+    (1, 2, 3, 6, 7) {'a': 8, 'b': 9, 'x': 4, 'y': 5}

+

+Examples with invalid arguments (TypeErrors). We're also testing the function

+names in the exception messages.

+

+Verify clearing of SF bug #733667

+

+    >>> e(c=4)

+    Traceback (most recent call last):

+      ...

+    TypeError: e() got an unexpected keyword argument 'c'

+

+    >>> g()

+    Traceback (most recent call last):

+      ...

+    TypeError: g() takes at least 1 argument (0 given)

+

+    >>> g(*())

+    Traceback (most recent call last):

+      ...

+    TypeError: g() takes at least 1 argument (0 given)

+

+    >>> g(*(), **{})

+    Traceback (most recent call last):

+      ...

+    TypeError: g() takes at least 1 argument (0 given)

+

+    >>> g(1)

+    1 () {}

+    >>> g(1, 2)

+    1 (2,) {}

+    >>> g(1, 2, 3)

+    1 (2, 3) {}

+    >>> g(1, 2, 3, *(4, 5))

+    1 (2, 3, 4, 5) {}

+

+    >>> class Nothing: pass

+    ...

+    >>> g(*Nothing())

+    Traceback (most recent call last):

+      ...

+    TypeError: g() argument after * must be a sequence, not instance

+

+    >>> class Nothing:

+    ...     def __len__(self): return 5

+    ...

+

+    >>> g(*Nothing())

+    Traceback (most recent call last):

+      ...

+    TypeError: g() argument after * must be a sequence, not instance

+

+    >>> class Nothing():

+    ...     def __len__(self): return 5

+    ...     def __getitem__(self, i):

+    ...         if i<3: return i

+    ...         else: raise IndexError(i)

+    ...

+

+    >>> g(*Nothing())

+    0 (1, 2) {}

+

+    >>> class Nothing:

+    ...     def __init__(self): self.c = 0

+    ...     def __iter__(self): return self

+    ...     def next(self):

+    ...         if self.c == 4:

+    ...             raise StopIteration

+    ...         c = self.c

+    ...         self.c += 1

+    ...         return c

+    ...

+

+    >>> g(*Nothing())

+    0 (1, 2, 3) {}

+

+Make sure that the function doesn't stomp the dictionary

+

+    >>> d = {'a': 1, 'b': 2, 'c': 3}

+    >>> d2 = d.copy()

+    >>> g(1, d=4, **d)

+    1 () {'a': 1, 'b': 2, 'c': 3, 'd': 4}

+    >>> d == d2

+    True

+

+What about willful misconduct?

+

+    >>> def saboteur(**kw):

+    ...     kw['x'] = 'm'

+    ...     return kw

+

+    >>> d = {}

+    >>> kw = saboteur(a=1, **d)

+    >>> d

+    {}

+

+

+    >>> g(1, 2, 3, **{'x': 4, 'y': 5})

+    Traceback (most recent call last):

+      ...

+    TypeError: g() got multiple values for keyword argument 'x'

+

+    >>> f(**{1:2})

+    Traceback (most recent call last):

+      ...

+    TypeError: f() keywords must be strings

+

+    >>> h(**{'e': 2})

+    Traceback (most recent call last):

+      ...

+    TypeError: h() got an unexpected keyword argument 'e'

+

+    >>> h(*h)

+    Traceback (most recent call last):

+      ...

+    TypeError: h() argument after * must be a sequence, not function

+

+    >>> dir(*h)

+    Traceback (most recent call last):

+      ...

+    TypeError: dir() argument after * must be a sequence, not function

+

+    >>> None(*h)

+    Traceback (most recent call last):

+      ...

+    TypeError: NoneType object argument after * must be a sequence, \

+not function

+

+    >>> h(**h)

+    Traceback (most recent call last):

+      ...

+    TypeError: h() argument after ** must be a mapping, not function

+

+    >>> dir(**h)

+    Traceback (most recent call last):

+      ...

+    TypeError: dir() argument after ** must be a mapping, not function

+

+    >>> None(**h)

+    Traceback (most recent call last):

+      ...

+    TypeError: NoneType object argument after ** must be a mapping, \

+not function

+

+    >>> dir(b=1, **{'b': 1})

+    Traceback (most recent call last):

+      ...

+    TypeError: dir() got multiple values for keyword argument 'b'

+

+Another helper function

+

+    >>> def f2(*a, **b):

+    ...     return a, b

+

+

+    >>> d = {}

+    >>> for i in xrange(512):

+    ...     key = 'k%d' % i

+    ...     d[key] = i

+    >>> a, b = f2(1, *(2,3), **d)

+    >>> len(a), len(b), b == d

+    (3, 512, True)

+

+    >>> class Foo:

+    ...     def method(self, arg1, arg2):

+    ...         return arg1+arg2

+

+    >>> x = Foo()

+    >>> Foo.method(*(x, 1, 2))

+    3

+    >>> Foo.method(x, *(1, 2))

+    3

+    >>> Foo.method(*(1, 2, 3))

+    Traceback (most recent call last):

+      ...

+    TypeError: unbound method method() must be called with Foo instance as \

+first argument (got int instance instead)

+

+    >>> Foo.method(1, *[2, 3])

+    Traceback (most recent call last):

+      ...

+    TypeError: unbound method method() must be called with Foo instance as \

+first argument (got int instance instead)

+

+A PyCFunction that takes only positional parameters should allow an

+empty keyword dictionary to pass without a complaint, but raise a

+TypeError if te dictionary is not empty

+

+    >>> try:

+    ...     silence = id(1, *{})

+    ...     True

+    ... except:

+    ...     False

+    True

+

+    >>> id(1, **{'foo': 1})

+    Traceback (most recent call last):

+      ...

+    TypeError: id() takes no keyword arguments

+

+A corner case of keyword dictionary items being deleted during

+the function call setup. See <http://bugs.python.org/issue2016>.

+

+    >>> class Name(str):

+    ...     def __eq__(self, other):

+    ...         try:

+    ...              del x[self]

+    ...         except KeyError:

+    ...              pass

+    ...         return str.__eq__(self, other)

+    ...     def __hash__(self):

+    ...         return str.__hash__(self)

+

+    >>> x = {Name("a"):1, Name("b"):2}

+    >>> def f(a, b):

+    ...     print a,b

+    >>> f(**x)

+    1 2

+

+A obscure message:

+

+    >>> def f(a, b):

+    ...    pass

+    >>> f(b=1)

+    Traceback (most recent call last):

+      ...

+    TypeError: f() takes exactly 2 arguments (1 given)

+

+The number of arguments passed in includes keywords:

+

+    >>> def f(a):

+    ...    pass

+    >>> f(6, a=4, *(1, 2, 3))

+    Traceback (most recent call last):

+      ...

+    TypeError: f() takes exactly 1 argument (5 given)

+"""

+

+import unittest

+import sys

+from test import test_support

+

+

+class ExtCallTest(unittest.TestCase):

+

+    def test_unicode_keywords(self):

+        def f(a):

+            return a

+        self.assertEqual(f(**{u'a': 4}), 4)

+        self.assertRaises(TypeError, f, **{u'stören': 4})

+        self.assertRaises(TypeError, f, **{u'someLongString':2})

+        try:

+            f(a=4, **{u'a': 4})

+        except TypeError:

+            pass

+        else:

+            self.fail("duplicate arguments didn't raise")

+

+

+def test_main():

+    test_support.run_doctest(sys.modules[__name__], True)

+    test_support.run_unittest(ExtCallTest)

+

+if __name__ == '__main__':

+    test_main()