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-2.7.2/Lib/test/test_userstring.py | 147 +++++++++++++++++++++ 1 file changed, 147 insertions(+) create mode 100644 AppPkg/Applications/Python/Python-2.7.2/Lib/test/test_userstring.py (limited to 'AppPkg/Applications/Python/Python-2.7.2/Lib/test/test_userstring.py') diff --git a/AppPkg/Applications/Python/Python-2.7.2/Lib/test/test_userstring.py b/AppPkg/Applications/Python/Python-2.7.2/Lib/test/test_userstring.py new file mode 100644 index 0000000000..a670d977e7 --- /dev/null +++ b/AppPkg/Applications/Python/Python-2.7.2/Lib/test/test_userstring.py @@ -0,0 +1,147 @@ +#!/usr/bin/env python +# UserString is a wrapper around the native builtin string type. +# UserString instances should behave similar to builtin string objects. + +import string +from test import test_support, string_tests +from UserString import UserString, MutableString +import warnings + +class UserStringTest( + string_tests.CommonTest, + string_tests.MixinStrUnicodeUserStringTest, + string_tests.MixinStrStringUserStringTest, + string_tests.MixinStrUserStringTest + ): + + type2test = UserString + + # Overwrite the three testing methods, because UserString + # can't cope with arguments propagated to UserString + # (and we don't test with subclasses) + def checkequal(self, result, object, methodname, *args): + result = self.fixtype(result) + object = self.fixtype(object) + # we don't fix the arguments, because UserString can't cope with it + realresult = getattr(object, methodname)(*args) + self.assertEqual( + result, + realresult + ) + + def checkraises(self, exc, object, methodname, *args): + object = self.fixtype(object) + # we don't fix the arguments, because UserString can't cope with it + self.assertRaises( + exc, + getattr(object, methodname), + *args + ) + + def checkcall(self, object, methodname, *args): + object = self.fixtype(object) + # we don't fix the arguments, because UserString can't cope with it + getattr(object, methodname)(*args) + +class MutableStringTest(UserStringTest): + type2test = MutableString + + # MutableStrings can be hashed => deactivate test + def test_hash(self): + pass + + def test_setitem(self): + s = self.type2test("foo") + self.assertRaises(IndexError, s.__setitem__, -4, "bar") + self.assertRaises(IndexError, s.__setitem__, 3, "bar") + s[-1] = "bar" + self.assertEqual(s, "fobar") + s[0] = "bar" + self.assertEqual(s, "barobar") + + def test_delitem(self): + s = self.type2test("foo") + self.assertRaises(IndexError, s.__delitem__, -4) + self.assertRaises(IndexError, s.__delitem__, 3) + del s[-1] + self.assertEqual(s, "fo") + del s[0] + self.assertEqual(s, "o") + del s[0] + self.assertEqual(s, "") + + def test_setslice(self): + s = self.type2test("foo") + s[:] = "bar" + self.assertEqual(s, "bar") + s[1:2] = "foo" + self.assertEqual(s, "bfoor") + s[1:-1] = UserString("a") + self.assertEqual(s, "bar") + s[0:10] = 42 + self.assertEqual(s, "42") + + def test_delslice(self): + s = self.type2test("foobar") + del s[3:10] + self.assertEqual(s, "foo") + del s[-1:10] + self.assertEqual(s, "fo") + + def test_extended_set_del_slice(self): + indices = (0, None, 1, 3, 19, 100, -1, -2, -31, -100) + orig = string.ascii_letters + string.digits + for start in indices: + for stop in indices: + # Use indices[1:] when MutableString can handle real + # extended slices + for step in (None, 1, -1): + s = self.type2test(orig) + L = list(orig) + # Make sure we have a slice of exactly the right length, + # but with (hopefully) different data. + data = L[start:stop:step] + data.reverse() + L[start:stop:step] = data + s[start:stop:step] = "".join(data) + self.assertEqual(s, "".join(L)) + + del L[start:stop:step] + del s[start:stop:step] + self.assertEqual(s, "".join(L)) + + def test_immutable(self): + s = self.type2test("foobar") + s2 = s.immutable() + self.assertEqual(s, s2) + self.assertIsInstance(s2, UserString) + + def test_iadd(self): + s = self.type2test("foo") + s += "bar" + self.assertEqual(s, "foobar") + s += UserString("baz") + self.assertEqual(s, "foobarbaz") + s += 42 + self.assertEqual(s, "foobarbaz42") + + def test_imul(self): + s = self.type2test("foo") + s *= 1 + self.assertEqual(s, "foo") + s *= 2 + self.assertEqual(s, "foofoo") + s *= -1 + self.assertEqual(s, "") + +def test_main(): + with warnings.catch_warnings(): + warnings.filterwarnings("ignore", ".*MutableString has been removed", + DeprecationWarning) + warnings.filterwarnings("ignore", + ".*__(get|set|del)slice__ has been removed", + DeprecationWarning) + test_support.run_unittest(UserStringTest, MutableStringTest) + +if __name__ == "__main__": + test_main() -- cgit v1.2.3