| import unittest |
| import __builtin__ |
| import exceptions |
| import warnings |
| from test.test_support import run_unittest |
| import os |
| from platform import system as platform_system |
| |
| class ExceptionClassTests(unittest.TestCase): |
| |
| """Tests for anything relating to exception objects themselves (e.g., |
| inheritance hierarchy)""" |
| |
| def test_builtins_new_style(self): |
| self.failUnless(issubclass(Exception, object)) |
| |
| def verify_instance_interface(self, ins): |
| for attr in ("args", "message", "__str__", "__repr__", "__getitem__"): |
| self.failUnless(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.failUnless(superclass_name in 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.failUnless(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.failUnless(exc_name in exc_set) |
| exc_set.discard(exc_name) |
| last_exc = exc |
| last_depth = depth |
| finally: |
| inheritance_tree.close() |
| self.failUnlessEqual(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.failUnlessEqual(given, expected, "%s: %s != %s" % (test_name, |
| given, expected)) |
| |
| 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) |
| |
| 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) |
| |
| 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) |
| |
| class UsageTests(unittest.TestCase): |
| |
| """Test usage of exceptions""" |
| |
| def setUp(self): |
| self._filters = warnings.filters[:] |
| |
| def tearDown(self): |
| warnings.filters = self._filters[:] |
| |
| def test_raise_new_style_non_exception(self): |
| class NewStyleClass(object): |
| pass |
| try: |
| raise NewStyleClass |
| except TypeError: |
| pass |
| except: |
| self.fail("unable to raise new-style class") |
| try: |
| raise NewStyleClass() |
| except TypeError: |
| pass |
| except: |
| self.fail("unable to raise new-style class instance") |
| |
| def test_main(): |
| run_unittest(ExceptionClassTests, UsageTests) |
| |
| if __name__ == '__main__': |
| test_main() |