From 4710c53dcad1ebf3755f3efb9e80ac24bd72a9b2 Mon Sep 17 00:00:00 2001 From: darylm503 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_richcmp.py | 338 +++++++++++++++++++++ 1 file changed, 338 insertions(+) create mode 100644 AppPkg/Applications/Python/Python-2.7.2/Lib/test/test_richcmp.py (limited to 'AppPkg/Applications/Python/Python-2.7.2/Lib/test/test_richcmp.py') diff --git a/AppPkg/Applications/Python/Python-2.7.2/Lib/test/test_richcmp.py b/AppPkg/Applications/Python/Python-2.7.2/Lib/test/test_richcmp.py new file mode 100644 index 0000000000..c69647ca92 --- /dev/null +++ b/AppPkg/Applications/Python/Python-2.7.2/Lib/test/test_richcmp.py @@ -0,0 +1,338 @@ +# Tests for rich comparisons + +import unittest +from test import test_support + +import operator + +class Number: + + def __init__(self, x): + self.x = x + + def __lt__(self, other): + return self.x < other + + def __le__(self, other): + return self.x <= other + + def __eq__(self, other): + return self.x == other + + def __ne__(self, other): + return self.x != other + + def __gt__(self, other): + return self.x > other + + def __ge__(self, other): + return self.x >= other + + def __cmp__(self, other): + raise test_support.TestFailed, "Number.__cmp__() should not be called" + + def __repr__(self): + return "Number(%r)" % (self.x, ) + +class Vector: + + def __init__(self, data): + self.data = data + + def __len__(self): + return len(self.data) + + def __getitem__(self, i): + return self.data[i] + + def __setitem__(self, i, v): + self.data[i] = v + + __hash__ = None # Vectors cannot be hashed + + def __nonzero__(self): + raise TypeError, "Vectors cannot be used in Boolean contexts" + + def __cmp__(self, other): + raise test_support.TestFailed, "Vector.__cmp__() should not be called" + + def __repr__(self): + return "Vector(%r)" % (self.data, ) + + def __lt__(self, other): + return Vector([a < b for a, b in zip(self.data, self.__cast(other))]) + + def __le__(self, other): + return Vector([a <= b for a, b in zip(self.data, self.__cast(other))]) + + def __eq__(self, other): + return Vector([a == b for a, b in zip(self.data, self.__cast(other))]) + + def __ne__(self, other): + return Vector([a != b for a, b in zip(self.data, self.__cast(other))]) + + def __gt__(self, other): + return Vector([a > b for a, b in zip(self.data, self.__cast(other))]) + + def __ge__(self, other): + return Vector([a >= b for a, b in zip(self.data, self.__cast(other))]) + + def __cast(self, other): + if isinstance(other, Vector): + other = other.data + if len(self.data) != len(other): + raise ValueError, "Cannot compare vectors of different length" + return other + +opmap = { + "lt": (lambda a,b: a< b, operator.lt, operator.__lt__), + "le": (lambda a,b: a<=b, operator.le, operator.__le__), + "eq": (lambda a,b: a==b, operator.eq, operator.__eq__), + "ne": (lambda a,b: a!=b, operator.ne, operator.__ne__), + "gt": (lambda a,b: a> b, operator.gt, operator.__gt__), + "ge": (lambda a,b: a>=b, operator.ge, operator.__ge__) +} + +class VectorTest(unittest.TestCase): + + def checkfail(self, error, opname, *args): + for op in opmap[opname]: + self.assertRaises(error, op, *args) + + def checkequal(self, opname, a, b, expres): + for op in opmap[opname]: + realres = op(a, b) + # can't use assertEqual(realres, expres) here + self.assertEqual(len(realres), len(expres)) + for i in xrange(len(realres)): + # results are bool, so we can use "is" here + self.assertTrue(realres[i] is expres[i]) + + def test_mixed(self): + # check that comparisons involving Vector objects + # which return rich results (i.e. Vectors with itemwise + # comparison results) work + a = Vector(range(2)) + b = Vector(range(3)) + # all comparisons should fail for different length + for opname in opmap: + self.checkfail(ValueError, opname, a, b) + + a = range(5) + b = 5 * [2] + # try mixed arguments (but not (a, b) as that won't return a bool vector) + args = [(a, Vector(b)), (Vector(a), b), (Vector(a), Vector(b))] + for (a, b) in args: + self.checkequal("lt", a, b, [True, True, False, False, False]) + self.checkequal("le", a, b, [True, True, True, False, False]) + self.checkequal("eq", a, b, [False, False, True, False, False]) + self.checkequal("ne", a, b, [True, True, False, True, True ]) + self.checkequal("gt", a, b, [False, False, False, True, True ]) + self.checkequal("ge", a, b, [False, False, True, True, True ]) + + for ops in opmap.itervalues(): + for op in ops: + # calls __nonzero__, which should fail + self.assertRaises(TypeError, bool, op(a, b)) + +class NumberTest(unittest.TestCase): + + def test_basic(self): + # Check that comparisons involving Number objects + # give the same results give as comparing the + # corresponding ints + for a in xrange(3): + for b in xrange(3): + for typea in (int, Number): + for typeb in (int, Number): + if typea==typeb==int: + continue # the combination int, int is useless + ta = typea(a) + tb = typeb(b) + for ops in opmap.itervalues(): + for op in ops: + realoutcome = op(a, b) + testoutcome = op(ta, tb) + self.assertEqual(realoutcome, testoutcome) + + def checkvalue(self, opname, a, b, expres): + for typea in (int, Number): + for typeb in (int, Number): + ta = typea(a) + tb = typeb(b) + for op in opmap[opname]: + realres = op(ta, tb) + realres = getattr(realres, "x", realres) + self.assertTrue(realres is expres) + + def test_values(self): + # check all operators and all comparison results + self.checkvalue("lt", 0, 0, False) + self.checkvalue("le", 0, 0, True ) + self.checkvalue("eq", 0, 0, True ) + self.checkvalue("ne", 0, 0, False) + self.checkvalue("gt", 0, 0, False) + self.checkvalue("ge", 0, 0, True ) + + self.checkvalue("lt", 0, 1, True ) + self.checkvalue("le", 0, 1, True ) + self.checkvalue("eq", 0, 1, False) + self.checkvalue("ne", 0, 1, True ) + self.checkvalue("gt", 0, 1, False) + self.checkvalue("ge", 0, 1, False) + + self.checkvalue("lt", 1, 0, False) + self.checkvalue("le", 1, 0, False) + self.checkvalue("eq", 1, 0, False) + self.checkvalue("ne", 1, 0, True ) + self.checkvalue("gt", 1, 0, True ) + self.checkvalue("ge", 1, 0, True ) + +class MiscTest(unittest.TestCase): + + def test_misbehavin(self): + class Misb: + def __lt__(self_, other): return 0 + def __gt__(self_, other): return 0 + def __eq__(self_, other): return 0 + def __le__(self_, other): self.fail("This shouldn't happen") + def __ge__(self_, other): self.fail("This shouldn't happen") + def __ne__(self_, other): self.fail("This shouldn't happen") + def __cmp__(self_, other): raise RuntimeError, "expected" + a = Misb() + b = Misb() + self.assertEqual(ab, 0) + self.assertRaises(RuntimeError, cmp, a, b) + + def test_not(self): + # Check that exceptions in __nonzero__ are properly + # propagated by the not operator + import operator + class Exc(Exception): + pass + class Bad: + def __nonzero__(self): + raise Exc + + def do(bad): + not bad + + for func in (do, operator.not_): + self.assertRaises(Exc, func, Bad()) + + def test_recursion(self): + # Check that comparison for recursive objects fails gracefully + from UserList import UserList + a = UserList() + b = UserList() + a.append(b) + b.append(a) + self.assertRaises(RuntimeError, operator.eq, a, b) + self.assertRaises(RuntimeError, operator.ne, a, b) + self.assertRaises(RuntimeError, operator.lt, a, b) + self.assertRaises(RuntimeError, operator.le, a, b) + self.assertRaises(RuntimeError, operator.gt, a, b) + self.assertRaises(RuntimeError, operator.ge, a, b) + + b.append(17) + # Even recursive lists of different lengths are different, + # but they cannot be ordered + self.assertTrue(not (a == b)) + self.assertTrue(a != b) + self.assertRaises(RuntimeError, operator.lt, a, b) + self.assertRaises(RuntimeError, operator.le, a, b) + self.assertRaises(RuntimeError, operator.gt, a, b) + self.assertRaises(RuntimeError, operator.ge, a, b) + a.append(17) + self.assertRaises(RuntimeError, operator.eq, a, b) + self.assertRaises(RuntimeError, operator.ne, a, b) + a.insert(0, 11) + b.insert(0, 12) + self.assertTrue(not (a == b)) + self.assertTrue(a != b) + self.assertTrue(a < b) + +class DictTest(unittest.TestCase): + + def test_dicts(self): + # Verify that __eq__ and __ne__ work for dicts even if the keys and + # values don't support anything other than __eq__ and __ne__ (and + # __hash__). Complex numbers are a fine example of that. + import random + imag1a = {} + for i in range(50): + imag1a[random.randrange(100)*1j] = random.randrange(100)*1j + items = imag1a.items() + random.shuffle(items) + imag1b = {} + for k, v in items: + imag1b[k] = v + imag2 = imag1b.copy() + imag2[k] = v + 1.0 + self.assertTrue(imag1a == imag1a) + self.assertTrue(imag1a == imag1b) + self.assertTrue(imag2 == imag2) + self.assertTrue(imag1a != imag2) + for opname in ("lt", "le", "gt", "ge"): + for op in opmap[opname]: + self.assertRaises(TypeError, op, imag1a, imag2) + +class ListTest(unittest.TestCase): + + def test_coverage(self): + # exercise all comparisons for lists + x = [42] + self.assertIs(xx, False) + self.assertIs(x>=x, True) + y = [42, 42] + self.assertIs(xy, False) + self.assertIs(x>=y, False) + + def test_badentry(self): + # make sure that exceptions for item comparison are properly + # propagated in list comparisons + class Exc(Exception): + pass + class Bad: + def __eq__(self, other): + raise Exc + + x = [Bad()] + y = [Bad()] + + for op in opmap["eq"]: + self.assertRaises(Exc, op, x, y) + + def test_goodentry(self): + # This test exercises the final call to PyObject_RichCompare() + # in Objects/listobject.c::list_richcompare() + class Good: + def __lt__(self, other): + return True + + x = [Good()] + y = [Good()] + + for op in opmap["lt"]: + self.assertIs(op(x, y), True) + +def test_main(): + test_support.run_unittest(VectorTest, NumberTest, MiscTest, ListTest) + with test_support.check_py3k_warnings(("dict inequality comparisons " + "not supported in 3.x", + DeprecationWarning)): + test_support.run_unittest(DictTest) + + +if __name__ == "__main__": + test_main() -- cgit v1.2.3