# Python test set -- part 5, built-in exceptions import os import sys import unittest import pickle import weakref from test.support import TESTFN, unlink, run_unittest # XXX This is not really enough, each *operation* should be tested! class ExceptionTests(unittest.TestCase): def raise_catch(self, exc, excname): try: raise exc("spam") except exc as err: buf1 = str(err) try: raise exc("spam") except exc as err: buf2 = str(err) self.assertEquals(buf1, buf2) self.assertEquals(exc.__name__, excname) def testRaising(self): self.raise_catch(AttributeError, "AttributeError") self.assertRaises(AttributeError, getattr, sys, "undefined_attribute") self.raise_catch(EOFError, "EOFError") fp = open(TESTFN, 'w') fp.close() fp = open(TESTFN, 'r') savestdin = sys.stdin try: try: import marshal marshal.loads('') except EOFError: pass finally: sys.stdin = savestdin fp.close() unlink(TESTFN) self.raise_catch(IOError, "IOError") self.assertRaises(IOError, open, 'this file does not exist', 'r') self.raise_catch(ImportError, "ImportError") self.assertRaises(ImportError, __import__, "undefined_module") self.raise_catch(IndexError, "IndexError") x = [] self.assertRaises(IndexError, x.__getitem__, 10) self.raise_catch(KeyError, "KeyError") x = {} self.assertRaises(KeyError, x.__getitem__, 'key') self.raise_catch(KeyboardInterrupt, "KeyboardInterrupt") self.raise_catch(MemoryError, "MemoryError") self.raise_catch(NameError, "NameError") try: x = undefined_variable except NameError: pass self.raise_catch(OverflowError, "OverflowError") x = 1 for dummy in range(128): x += x # this simply shouldn't blow up self.raise_catch(RuntimeError, "RuntimeError") self.raise_catch(SyntaxError, "SyntaxError") try: exec('/\n') except SyntaxError: pass self.raise_catch(IndentationError, "IndentationError") self.raise_catch(TabError, "TabError") try: compile("try:\n\t1/0\n \t1/0\nfinally:\n pass\n", '', 'exec') except TabError: pass else: self.fail("TabError not raised") self.raise_catch(SystemError, "SystemError") self.raise_catch(SystemExit, "SystemExit") self.assertRaises(SystemExit, sys.exit, 0) self.raise_catch(TypeError, "TypeError") try: [] + () except TypeError: pass self.raise_catch(ValueError, "ValueError") self.assertRaises(ValueError, chr, 17<<16) self.raise_catch(ZeroDivisionError, "ZeroDivisionError") try: x = 1/0 except ZeroDivisionError: pass self.raise_catch(Exception, "Exception") try: x = 1/0 except Exception as e: pass def testSyntaxErrorMessage(self): # make sure the right exception message is raised for each of # these code fragments def ckmsg(src, msg): try: compile(src, '', 'exec') except SyntaxError as e: if e.msg != msg: self.fail("expected %s, got %s" % (msg, e.msg)) else: self.fail("failed to get expected SyntaxError") s = '''while 1: try: pass finally: continue''' if not sys.platform.startswith('java'): ckmsg(s, "'continue' not supported inside 'finally' clause") s = '''if 1: try: continue except: pass''' ckmsg(s, "'continue' not properly in loop") ckmsg("continue\n", "'continue' not properly in loop") def testSettingException(self): # test that setting an exception at the C level works even if the # exception object can't be constructed. class BadException(Exception): def __init__(self_): raise RuntimeError("can't instantiate BadException") class InvalidException: pass def test_capi1(): import _testcapi try: _testcapi.raise_exception(BadException, 1) except TypeError as err: exc, err, tb = sys.exc_info() co = tb.tb_frame.f_code self.assertEquals(co.co_name, "test_capi1") self.assert_(co.co_filename.endswith('test_exceptions.py')) else: self.fail("Expected exception") def test_capi2(): import _testcapi try: _testcapi.raise_exception(BadException, 0) except RuntimeError as err: exc, err, tb = sys.exc_info() co = tb.tb_frame.f_code self.assertEquals(co.co_name, "__init__") self.assert_(co.co_filename.endswith('test_exceptions.py')) co2 = tb.tb_frame.f_back.f_code self.assertEquals(co2.co_name, "test_capi2") else: self.fail("Expected exception") def test_capi3(): import _testcapi self.assertRaises(SystemError, _testcapi.raise_exception, InvalidException, 1) if not sys.platform.startswith('java'): test_capi1() test_capi2() test_capi3() def test_WindowsError(self): try: WindowsError except NameError: pass else: self.failUnlessEqual(str(WindowsError(1001)), "1001") self.failUnlessEqual(str(WindowsError(1001, "message")), "[Error 1001] message") self.failUnlessEqual(WindowsError(1001, "message").errno, 22) self.failUnlessEqual(WindowsError(1001, "message").winerror, 1001) def testAttributes(self): # test that exception attributes are happy exceptionList = [ (BaseException, (), {'args' : ()}), (BaseException, (1, ), {'args' : (1,)}), (BaseException, ('foo',), {'args' : ('foo',)}), (BaseException, ('foo', 1), {'args' : ('foo', 1)}), (SystemExit, ('foo',), {'args' : ('foo',), 'code' : 'foo'}), (IOError, ('foo',), {'args' : ('foo',), 'filename' : None, 'errno' : None, 'strerror' : None}), (IOError, ('foo', 'bar'), {'args' : ('foo', 'bar'), 'filename' : None, 'errno' : 'foo', 'strerror' : 'bar'}), (IOError, ('foo', 'bar', 'baz'), {'args' : ('foo', 'bar'), 'filename' : 'baz', 'errno' : 'foo', 'strerror' : 'bar'}), (IOError, ('foo', 'bar', 'baz', 'quux'), {'args' : ('foo', 'bar', 'baz', 'quux')}), (EnvironmentError, ('errnoStr', 'strErrorStr', 'filenameStr'), {'args' : ('errnoStr', 'strErrorStr'), 'strerror' : 'strErrorStr', 'errno' : 'errnoStr', 'filename' : 'filenameStr'}), (EnvironmentError, (1, 'strErrorStr', 'filenameStr'), {'args' : (1, 'strErrorStr'), 'errno' : 1, 'strerror' : 'strErrorStr', 'filename' : 'filenameStr'}), (SyntaxError, (), {'msg' : None, 'text' : None, 'filename' : None, 'lineno' : None, 'offset' : None, 'print_file_and_line' : None}), (SyntaxError, ('msgStr',), {'args' : ('msgStr',), 'text' : None, 'print_file_and_line' : None, 'msg' : 'msgStr', 'filename' : None, 'lineno' : None, 'offset' : None}), (SyntaxError, ('msgStr', ('filenameStr', 'linenoStr', 'offsetStr', 'textStr')), {'offset' : 'offsetStr', 'text' : 'textStr', 'args' : ('msgStr', ('filenameStr', 'linenoStr', 'offsetStr', 'textStr')), 'print_file_and_line' : None, 'msg' : 'msgStr', 'filename' : 'filenameStr', 'lineno' : 'linenoStr'}), (SyntaxError, ('msgStr', 'filenameStr', 'linenoStr', 'offsetStr', 'textStr', 'print_file_and_lineStr'), {'text' : None, 'args' : ('msgStr', 'filenameStr', 'linenoStr', 'offsetStr', 'textStr', 'print_file_and_lineStr'), 'print_file_and_line' : None, 'msg' : 'msgStr', 'filename' : None, 'lineno' : None, 'offset' : None}), (UnicodeError, (), {'args' : (),}), (UnicodeEncodeError, ('ascii', 'a', 0, 1, 'ordinal not in range'), {'args' : ('ascii', 'a', 0, 1, 'ordinal not in range'), 'encoding' : 'ascii', 'object' : 'a', 'start' : 0, 'reason' : 'ordinal not in range'}), (UnicodeDecodeError, ('ascii', bytearray(b'\xff'), 0, 1, 'ordinal not in range'), {'args' : ('ascii', bytearray(b'\xff'), 0, 1, 'ordinal not in range'), 'encoding' : 'ascii', 'object' : b'\xff', 'start' : 0, 'reason' : 'ordinal not in range'}), (UnicodeDecodeError, ('ascii', b'\xff', 0, 1, 'ordinal not in range'), {'args' : ('ascii', b'\xff', 0, 1, 'ordinal not in range'), 'encoding' : 'ascii', 'object' : b'\xff', 'start' : 0, 'reason' : 'ordinal not in range'}), (UnicodeTranslateError, ("\u3042", 0, 1, "ouch"), {'args' : ('\u3042', 0, 1, 'ouch'), 'object' : '\u3042', 'reason' : 'ouch', 'start' : 0, 'end' : 1}), ] try: exceptionList.append( (WindowsError, (1, 'strErrorStr', 'filenameStr'), {'args' : (1, 'strErrorStr'), 'strerror' : 'strErrorStr', 'winerror' : 1, 'errno' : 22, 'filename' : 'filenameStr'}) ) except NameError: pass for exc, args, expected in exceptionList: try: e = exc(*args) except: print("\nexc=%r, args=%r" % (exc, args), file=sys.stderr) raise else: # Verify module name self.assertEquals(type(e).__module__, 'builtins') # Verify no ref leaks in Exc_str() s = str(e) for checkArgName in expected: value = getattr(e, checkArgName) self.assertEquals(repr(value), repr(expected[checkArgName]), '%r.%s == %r, expected %r' % ( e, checkArgName, value, expected[checkArgName])) # test for pickling support for p in [pickle]: for protocol in range(p.HIGHEST_PROTOCOL + 1): s = p.dumps(e, protocol) new = p.loads(s) for checkArgName in expected: got = repr(getattr(new, checkArgName)) want = repr(expected[checkArgName]) self.assertEquals(got, want, 'pickled "%r", attribute "%s' % (e, checkArgName)) def testWithTraceback(self): try: raise IndexError(4) except: tb = sys.exc_info()[2] e = BaseException().with_traceback(tb) self.failUnless(isinstance(e, BaseException)) self.assertEqual(e.__traceback__, tb) e = IndexError(5).with_traceback(tb) self.failUnless(isinstance(e, IndexError)) self.assertEqual(e.__traceback__, tb) class MyException(Exception): pass e = MyException().with_traceback(tb) self.failUnless(isinstance(e, MyException)) self.assertEqual(e.__traceback__, tb) def testInvalidTraceback(self): try: Exception().__traceback__ = 5 except TypeError as e: self.failUnless("__traceback__ must be a traceback" in str(e)) else: self.fail("No exception raised") def testNoneClearsTracebackAttr(self): try: raise IndexError(4) except: tb = sys.exc_info()[2] e = Exception() e.__traceback__ = tb e.__traceback__ = None self.assertEqual(e.__traceback__, None) def testChainingAttrs(self): e = Exception() self.assertEqual(e.__context__, None) self.assertEqual(e.__cause__, None) e = TypeError() self.assertEqual(e.__context__, None) self.assertEqual(e.__cause__, None) class MyException(EnvironmentError): pass e = MyException() self.assertEqual(e.__context__, None) self.assertEqual(e.__cause__, None) def testKeywordArgs(self): # test that builtin exception don't take keyword args, # but user-defined subclasses can if they want self.assertRaises(TypeError, BaseException, a=1) class DerivedException(BaseException): def __init__(self, fancy_arg): BaseException.__init__(self) self.fancy_arg = fancy_arg x = DerivedException(fancy_arg=42) self.assertEquals(x.fancy_arg, 42) def testInfiniteRecursion(self): def f(): return f() self.assertRaises(RuntimeError, f) def g(): try: return g() except ValueError: return -1 self.assertRaises(RuntimeError, g) def testUnicodeStrUsage(self): # Make sure both instances and classes have a str and unicode # representation. self.failUnless(str(Exception)) self.failUnless(str(Exception)) self.failUnless(str(Exception('a'))) self.failUnless(str(Exception('a'))) def testExceptionCleanupNames(self): # Make sure the local variable bound to the exception instance by # an "except" statement is only visible inside the except block. try: raise Exception() except Exception as e: self.failUnless(e) del e self.failIf('e' in locals()) def testExceptionCleanupState(self): # Make sure exception state is cleaned up as soon as the except # block is left. See #2507 class MyException(Exception): def __init__(self, obj): self.obj = obj class MyObj: pass def inner_raising_func(): # Create some references in exception value and traceback local_ref = obj raise MyException(obj) # Qualified "except" with "as" obj = MyObj() wr = weakref.ref(obj) try: inner_raising_func() except MyException as e: pass obj = None obj = wr() self.failUnless(obj is None, "%s" % obj) # Qualified "except" without "as" obj = MyObj() wr = weakref.ref(obj) try: inner_raising_func() except MyException: pass obj = None obj = wr() self.failUnless(obj is None, "%s" % obj) # Bare "except" obj = MyObj() wr = weakref.ref(obj) try: inner_raising_func() except: pass obj = None obj = wr() self.failUnless(obj is None, "%s" % obj) # "except" with premature block leave obj = MyObj() wr = weakref.ref(obj) for i in [0]: try: inner_raising_func() except: break obj = None obj = wr() self.failUnless(obj is None, "%s" % obj) # "except" block raising another exception obj = MyObj() wr = weakref.ref(obj) try: try: inner_raising_func() except: raise KeyError except KeyError as e: # We want to test that the except block above got rid of # the exception raised in inner_raising_func(), but it # also ends up in the __context__ of the KeyError, so we # must clear the latter manually for our test to succeed. e.__context__ = None obj = None obj = wr() self.failUnless(obj is None, "%s" % obj) # Some complicated construct obj = MyObj() wr = weakref.ref(obj) try: inner_raising_func() except MyException: try: try: raise finally: raise except MyException: pass obj = None obj = wr() self.failUnless(obj is None, "%s" % obj) # Inside an exception-silencing "with" block class Context: def __enter__(self): return self def __exit__ (self, exc_type, exc_value, exc_tb): return True obj = MyObj() wr = weakref.ref(obj) with Context(): inner_raising_func() obj = None obj = wr() self.failUnless(obj is None, "%s" % obj) def test_generator_leaking(self): # Test that generator exception state doesn't leak into the calling # frame def yield_raise(): try: raise KeyError("caught") except KeyError: yield sys.exc_info()[0] yield sys.exc_info()[0] yield sys.exc_info()[0] g = yield_raise() self.assertEquals(next(g), KeyError) self.assertEquals(sys.exc_info()[0], None) self.assertEquals(next(g), KeyError) self.assertEquals(sys.exc_info()[0], None) self.assertEquals(next(g), None) # Same test, but inside an exception handler try: raise TypeError("foo") except TypeError: g = yield_raise() self.assertEquals(next(g), KeyError) self.assertEquals(sys.exc_info()[0], TypeError) self.assertEquals(next(g), KeyError) self.assertEquals(sys.exc_info()[0], TypeError) self.assertEquals(next(g), TypeError) del g self.assertEquals(sys.exc_info()[0], TypeError) def test_3114(self): # Bug #3114: in its destructor, MyObject retrieves a pointer to # obsolete and/or deallocated objects. class MyObject: def __del__(self): nonlocal e e = sys.exc_info() e = () try: raise Exception(MyObject()) except: pass self.assertEquals(e, (None, None, None)) def test_main(): run_unittest(ExceptionTests) if __name__ == '__main__': unittest.main()