mirror of https://github.com/python/cpython
250 lines
9.2 KiB
Python
250 lines
9.2 KiB
Python
import unittest
|
|
import __builtin__
|
|
import exceptions
|
|
import warnings
|
|
from test.test_support import run_unittest
|
|
import os
|
|
from platform import system as platform_system
|
|
|
|
def ignore_message_warning():
|
|
"""Ignore the DeprecationWarning for BaseException.message."""
|
|
warnings.resetwarnings()
|
|
warnings.filterwarnings("ignore", "BaseException.message",
|
|
DeprecationWarning)
|
|
|
|
|
|
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):
|
|
with warnings.catch_warnings():
|
|
ignore_message_warning()
|
|
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)
|
|
with warnings.catch_warnings():
|
|
ignore_message_warning()
|
|
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)
|
|
with warnings.catch_warnings():
|
|
ignore_message_warning()
|
|
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()
|
|
with warnings.catch_warnings():
|
|
ignore_message_warning()
|
|
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 warnings.catch_warnings():
|
|
warnings.resetwarnings()
|
|
warnings.filterwarnings('error')
|
|
|
|
try:
|
|
BaseException().message
|
|
except DeprecationWarning:
|
|
pass
|
|
else:
|
|
self.fail("BaseException.message not deprecated")
|
|
|
|
|
|
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_))
|
|
|
|
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 class 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"
|
|
try:
|
|
try:
|
|
raise StandardError
|
|
except str_exc:
|
|
pass
|
|
except DeprecationWarning:
|
|
pass
|
|
except StandardError:
|
|
self.fail("catching a string exception did not raise "
|
|
"DeprecationWarning")
|
|
# Make sure that even if the string exception is listed in a tuple
|
|
# that a warning is raised.
|
|
try:
|
|
try:
|
|
raise StandardError
|
|
except (AssertionError, str_exc):
|
|
pass
|
|
except DeprecationWarning:
|
|
pass
|
|
except StandardError:
|
|
self.fail("catching a string exception specified in a tuple did "
|
|
"not raise DeprecationWarning")
|
|
|
|
|
|
def test_main():
|
|
run_unittest(ExceptionClassTests, UsageTests)
|
|
|
|
|
|
|
|
if __name__ == '__main__':
|
|
test_main()
|