| 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() |