diff options
Diffstat (limited to 'AppPkg/Applications/Python/Python-2.7.2/Lib/test/test_pep352.py')
| -rw-r--r-- | AppPkg/Applications/Python/Python-2.7.2/Lib/test/test_pep352.py | 239 |
1 files changed, 239 insertions, 0 deletions
diff --git a/AppPkg/Applications/Python/Python-2.7.2/Lib/test/test_pep352.py b/AppPkg/Applications/Python/Python-2.7.2/Lib/test/test_pep352.py new file mode 100644 index 0000000000..8445ac26d9 --- /dev/null +++ b/AppPkg/Applications/Python/Python-2.7.2/Lib/test/test_pep352.py @@ -0,0 +1,239 @@ +import unittest
+import __builtin__
+import exceptions
+import warnings
+from test.test_support import run_unittest, check_warnings
+import os
+import sys
+from platform import system as platform_system
+
+DEPRECATION_WARNINGS = ["BaseException.message has been deprecated"]
+
+if sys.py3kwarning:
+ DEPRECATION_WARNINGS.extend(
+ ["exceptions must derive from BaseException",
+ "catching classes that don't inherit from BaseException is not allowed",
+ "__get(item|slice)__ not supported for exception classes"])
+
+_deprecations = [(msg, DeprecationWarning) for msg in DEPRECATION_WARNINGS]
+
+# Silence Py3k and other deprecation warnings
+def ignore_deprecation_warnings(func):
+ """Ignore the known DeprecationWarnings."""
+ def wrapper(*args, **kw):
+ with check_warnings(*_deprecations, quiet=True):
+ return func(*args, **kw)
+ return wrapper
+
+class ExceptionClassTests(unittest.TestCase):
+
+ """Tests for anything relating to exception objects themselves (e.g.,
+ inheritance hierarchy)"""
+
+ def test_builtins_new_style(self):
+ self.assertTrue(issubclass(Exception, object))
+
+ @ignore_deprecation_warnings
+ def verify_instance_interface(self, ins):
+ for attr in ("args", "message", "__str__", "__repr__", "__getitem__"):
+ self.assertTrue(hasattr(ins, attr),
+ "%s missing %s attribute" %
+ (ins.__class__.__name__, attr))
+
+ def test_inheritance(self):
+ # Make sure the inheritance hierarchy matches the documentation
+ exc_set = set(x for x in dir(exceptions) if not x.startswith('_'))
+ inheritance_tree = open(os.path.join(os.path.split(__file__)[0],
+ 'exception_hierarchy.txt'))
+ try:
+ superclass_name = inheritance_tree.readline().rstrip()
+ try:
+ last_exc = getattr(__builtin__, superclass_name)
+ except AttributeError:
+ self.fail("base class %s not a built-in" % superclass_name)
+ self.assertIn(superclass_name, exc_set)
+ exc_set.discard(superclass_name)
+ superclasses = [] # Loop will insert base exception
+ last_depth = 0
+ for exc_line in inheritance_tree:
+ exc_line = exc_line.rstrip()
+ depth = exc_line.rindex('-')
+ exc_name = exc_line[depth+2:] # Slice past space
+ if '(' in exc_name:
+ paren_index = exc_name.index('(')
+ platform_name = exc_name[paren_index+1:-1]
+ exc_name = exc_name[:paren_index-1] # Slice off space
+ if platform_system() != platform_name:
+ exc_set.discard(exc_name)
+ continue
+ if '[' in exc_name:
+ left_bracket = exc_name.index('[')
+ exc_name = exc_name[:left_bracket-1] # cover space
+ try:
+ exc = getattr(__builtin__, exc_name)
+ except AttributeError:
+ self.fail("%s not a built-in exception" % exc_name)
+ if last_depth < depth:
+ superclasses.append((last_depth, last_exc))
+ elif last_depth > depth:
+ while superclasses[-1][0] >= depth:
+ superclasses.pop()
+ self.assertTrue(issubclass(exc, superclasses[-1][1]),
+ "%s is not a subclass of %s" % (exc.__name__,
+ superclasses[-1][1].__name__))
+ try: # Some exceptions require arguments; just skip them
+ self.verify_instance_interface(exc())
+ except TypeError:
+ pass
+ self.assertIn(exc_name, exc_set)
+ exc_set.discard(exc_name)
+ last_exc = exc
+ last_depth = depth
+ finally:
+ inheritance_tree.close()
+ self.assertEqual(len(exc_set), 0, "%s not accounted for" % exc_set)
+
+ interface_tests = ("length", "args", "message", "str", "unicode", "repr",
+ "indexing")
+
+ def interface_test_driver(self, results):
+ for test_name, (given, expected) in zip(self.interface_tests, results):
+ self.assertEqual(given, expected, "%s: %s != %s" % (test_name,
+ given, expected))
+
+ @ignore_deprecation_warnings
+ def test_interface_single_arg(self):
+ # Make sure interface works properly when given a single argument
+ arg = "spam"
+ exc = Exception(arg)
+ results = ([len(exc.args), 1], [exc.args[0], arg], [exc.message, arg],
+ [str(exc), str(arg)], [unicode(exc), unicode(arg)],
+ [repr(exc), exc.__class__.__name__ + repr(exc.args)],
+ [exc[0], arg])
+ self.interface_test_driver(results)
+
+ @ignore_deprecation_warnings
+ def test_interface_multi_arg(self):
+ # Make sure interface correct when multiple arguments given
+ arg_count = 3
+ args = tuple(range(arg_count))
+ exc = Exception(*args)
+ results = ([len(exc.args), arg_count], [exc.args, args],
+ [exc.message, ''], [str(exc), str(args)],
+ [unicode(exc), unicode(args)],
+ [repr(exc), exc.__class__.__name__ + repr(exc.args)],
+ [exc[-1], args[-1]])
+ self.interface_test_driver(results)
+
+ @ignore_deprecation_warnings
+ def test_interface_no_arg(self):
+ # Make sure that with no args that interface is correct
+ exc = Exception()
+ results = ([len(exc.args), 0], [exc.args, tuple()],
+ [exc.message, ''],
+ [str(exc), ''], [unicode(exc), u''],
+ [repr(exc), exc.__class__.__name__ + '()'], [True, True])
+ self.interface_test_driver(results)
+
+
+ def test_message_deprecation(self):
+ # As of Python 2.6, BaseException.message is deprecated.
+ with check_warnings(("", DeprecationWarning)):
+ BaseException().message
+
+
+class UsageTests(unittest.TestCase):
+
+ """Test usage of exceptions"""
+
+ def raise_fails(self, object_):
+ """Make sure that raising 'object_' triggers a TypeError."""
+ try:
+ raise object_
+ except TypeError:
+ return # What is expected.
+ self.fail("TypeError expected for raising %s" % type(object_))
+
+ def catch_fails(self, object_):
+ """Catching 'object_' should raise a TypeError."""
+ try:
+ try:
+ raise StandardError
+ except object_:
+ pass
+ except TypeError:
+ pass
+ except StandardError:
+ self.fail("TypeError expected when catching %s" % type(object_))
+
+ try:
+ try:
+ raise StandardError
+ except (object_,):
+ pass
+ except TypeError:
+ return
+ except StandardError:
+ self.fail("TypeError expected when catching %s as specified in a "
+ "tuple" % type(object_))
+
+ @ignore_deprecation_warnings
+ def test_raise_classic(self):
+ # Raising a classic class is okay (for now).
+ class ClassicClass:
+ pass
+ try:
+ raise ClassicClass
+ except ClassicClass:
+ pass
+ except:
+ self.fail("unable to raise classic class")
+ try:
+ raise ClassicClass()
+ except ClassicClass:
+ pass
+ except:
+ self.fail("unable to raise classic class instance")
+
+ def test_raise_new_style_non_exception(self):
+ # You cannot raise a new-style class that does not inherit from
+ # BaseException; the ability was not possible until BaseException's
+ # introduction so no need to support new-style objects that do not
+ # inherit from it.
+ class NewStyleClass(object):
+ pass
+ self.raise_fails(NewStyleClass)
+ self.raise_fails(NewStyleClass())
+
+ def test_raise_string(self):
+ # Raising a string raises TypeError.
+ self.raise_fails("spam")
+
+ def test_catch_string(self):
+ # Catching a string should trigger a DeprecationWarning.
+ with warnings.catch_warnings():
+ warnings.resetwarnings()
+ warnings.filterwarnings("error")
+ str_exc = "spam"
+ with self.assertRaises(DeprecationWarning):
+ try:
+ raise StandardError
+ except str_exc:
+ pass
+
+ # Make sure that even if the string exception is listed in a tuple
+ # that a warning is raised.
+ with self.assertRaises(DeprecationWarning):
+ try:
+ raise StandardError
+ except (AssertionError, str_exc):
+ pass
+
+
+def test_main():
+ run_unittest(ExceptionClassTests, UsageTests)
+
+
+
+if __name__ == '__main__':
+ test_main()
|