diff options
Diffstat (limited to 'lib/python2.7/test/test_pep352.py')
| -rw-r--r-- | lib/python2.7/test/test_pep352.py | 239 |
1 files changed, 0 insertions, 239 deletions
diff --git a/lib/python2.7/test/test_pep352.py b/lib/python2.7/test/test_pep352.py deleted file mode 100644 index 88b3136..0000000 --- a/lib/python2.7/test/test_pep352.py +++ /dev/null @@ -1,239 +0,0 @@ -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() |