# Python test set -- part 5, built-in exceptions

import copy

import os

import sys

import unittest

import pickle

import weakref

import errno

from codecs import BOM_UTF8

from itertools import product

from textwrap import dedent

from types import ModuleType

from test.support import (captured_stderr, check_impl_detail,

cpython_only, gc_collect,

no_tracing, script_helper,

SuppressCrashReport,

force_not_colorized)

from test.support.import_helper import import_module

from test.support.os_helper import TESTFN, unlink

from test.support.warnings_helper import check_warnings

from test import support

try:

import _testcapi

from _testcapi import INT_MAX

except ImportError:

_testcapi = None

INT_MAX = 2**31 - 1

class NaiveException(Exception):

def __init__(self, x):

self.x = x

class SlottedNaiveException(Exception):

__slots__ = ('x',)

def __init__(self, x):

self.x = x

class BrokenStrException(Exception):

def __str__(self):

raise Exception("str() is broken")

# XXX This is not really enough, each *operation* should be tested!

class ExceptionTests(unittest.TestCase):

def raise_catch(self, exc, excname):

with self.subTest(exc=exc, excname=excname):

try:

raise exc("spam")

except exc as err:

buf1 = str(err)

try:

raise exc("spam")

except exc as err:

buf2 = str(err)

self.assertEqual(buf1, buf2)

self.assertEqual(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', encoding="utf-8")

fp.close()

fp = open(TESTFN, 'r', encoding="utf-8")

savestdin = sys.stdin

try:

try:

import marshal

marshal.loads(b'')

except EOFError:

pass

finally:

sys.stdin = savestdin

fp.close()

unlink(TESTFN)

self.raise_catch(OSError, "OSError")

self.assertRaises(OSError, 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(RecursionError, "RecursionError")

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",

'<string>', '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

self.raise_catch(StopAsyncIteration, "StopAsyncIteration")

def testSyntaxErrorMessage(self):

# make sure the right exception message is raised for each of

# these code fragments

def ckmsg(src, msg):

with self.subTest(src=src, msg=msg):

try:

compile(src, '<fragment>', '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 = '''if 1:

try:

continue

except:

pass'''

ckmsg(s, "'continue' not properly in loop")

ckmsg("continue\n", "'continue' not properly in loop")

ckmsg("f'{6 0}'", "invalid syntax. Perhaps you forgot a comma?")

def testSyntaxErrorMissingParens(self):

def ckmsg(src, msg, exception=SyntaxError):

try:

compile(src, '<fragment>', 'exec')

except exception as e:

if e.msg != msg:

self.fail("expected %s, got %s" % (msg, e.msg))

else:

self.fail("failed to get expected SyntaxError")

s = '''print "old style"'''

ckmsg(s, "Missing parentheses in call to 'print'. Did you mean print(...)?")

s = '''print "old style",'''

ckmsg(s, "Missing parentheses in call to 'print'. Did you mean print(...)?")

s = 'print f(a+b,c)'

ckmsg(s, "Missing parentheses in call to 'print'. Did you mean print(...)?")

s = '''exec "old style"'''

ckmsg(s, "Missing parentheses in call to 'exec'. Did you mean exec(...)?")

s = 'exec f(a+b,c)'

ckmsg(s, "Missing parentheses in call to 'exec'. Did you mean exec(...)?")

# Check that we don't incorrectly identify '(...)' as an expression to the right

# of 'print'

s = 'print (a+b,c) $ 42'

ckmsg(s, "invalid syntax")

s = 'exec (a+b,c) $ 42'

ckmsg(s, "invalid syntax")

# should not apply to subclasses, see issue #31161

s = '''if True:\nprint "No indent"'''

ckmsg(s, "expected an indented block after 'if' statement on line 1", IndentationError)

s = '''if True:\n print()\n\texec "mixed tabs and spaces"'''

ckmsg(s, "inconsistent use of tabs and spaces in indentation", TabError)

def check(self, src, lineno, offset, end_lineno=None, end_offset=None, encoding='utf-8'):

with self.subTest(source=src, lineno=lineno, offset=offset):

with self.assertRaises(SyntaxError) as cm:

compile(src, '<fragment>', 'exec')

self.assertEqual(cm.exception.lineno, lineno)

self.assertEqual(cm.exception.offset, offset)

if end_lineno is not None:

self.assertEqual(cm.exception.end_lineno, end_lineno)

if end_offset is not None:

self.assertEqual(cm.exception.end_offset, end_offset)

if cm.exception.text is not None:

if not isinstance(src, str):

src = src.decode(encoding, 'replace')

line = src.split('\n')[lineno-1]

if lineno == 1:

line = line.removeprefix('\ufeff')

self.assertIn(line, cm.exception.text)

def test_error_offset_continuation_characters(self):

check = self.check

check('"\\\n"(1 for c in I,\\\n\\', 2, 2)

def testSyntaxErrorRange(self):

# gh-156894: the position was reported in bytes, not in characters,

# for the errors which cover a range

for source, offset, end_offset in [

('abcd = 00010', 8, 11),

('\u03b1\u03b2\u03b3\u03b4 = 00010', 8, 11),

('a\u0301b\u0308c\u20d7d\u1ab0 = 00010', 12, 15),

("abcd = ub'a'", 8, 10),

("\u03b1\u03b2\u03b3\u03b4 = ub'a'", 8, 10),

("a\u0301b\u0308c\u20d7d\u1ab0 = ub'a'", 12, 14),

]:

with self.subTest(source=source):

with self.assertRaises(SyntaxError) as cm:

compile(source, '<testcase>', 'exec')

self.assertEqual(cm.exception.offset, offset)

self.assertEqual(cm.exception.end_offset, end_offset)

def testSyntaxErrorNonUTF8Offset(self):

# gh-157378: the position was reported one column short for each

# multi-byte character preceding the invalid byte on the same line

check = self.check

check(b'X\x80', 1, 2, 1, 2)

check(b'\xc3\xa9X\x80', 1, 3, 1, 3)

check(b'\t\xc3\xa9X\x80', 1, 4, 1, 4)

check(b'a\xc3\xa9b\x80c', 1, 4, 1, 4)

check(b'a\n\xc3\xa9X\x80', 2, 3, 2, 3)

def testSyntaxErrorOffset(self):

check = self.check

check('def fact(x):\n\treturn x!\n', 2, 10)

check('1 +\n', 1, 4)

check('def spam():\n print(1)\n print(2)', 3, 10)

check('Python = "Python" +', 1, 20)

check('Python = "\u1e54\xfd\u0163\u0125\xf2\xf1" +', 1, 20)

check(b'# -*- coding: cp1251 -*-\nPython = "\xcf\xb3\xf2\xee\xed" +',

2, 19, encoding='cp1251')

check(b'Python = "\xcf\xb3\xf2\xee\xed" +', 1, 12)

check(b'\n\n\nPython = "\xcf\xb3\xf2\xee\xed" +', 4, 12)

check(b'\xef\xbb\xbfPython = "\xcf\xb3\xf2\xee\xed" +', 1, 12)

check('x = "a', 1, 5)

check('lambda x: x = 2', 1, 1)

check('f{a + b + c}', 1, 2)

check('[file for str(file) in []\n]', 1, 11)

check('a = « hello » « world »', 1, 5)

check('[\nfile\nfor str(file)\nin\n[]\n]', 3, 5)

check('[file for\n str(file) in []]', 2, 2)

check("ages = {'Alice'=22, 'Bob'=23}", 1, 9)

check(dedent("""\

match ...:

case {**rest1, "after": after}:

...

"""), 2, 11)

check(dedent("""\

match ...:

case {"before": before, **rest2, "after": after}:

...

"""), 2, 29)

check("[a b c d e f]", 1, 2)

check("for x yfff:", 1, 7)

check("f(a for a in b, c)", 1, 3, 1, 15)

check("f(a for a in b if a, c)", 1, 3, 1, 20)

check("f(a, b for b in c)", 1, 6, 1, 18)

check("f(a, b for b in c, d)", 1, 6, 1, 18)

# Errors thrown by compile.c

check('class foo:return 1', 1, 11)

check('def f():\n continue', 2, 3)

check('def f():\n break', 2, 3)

check('try:\n pass\nexcept:\n pass\nexcept ValueError:\n pass', 3, 1)

check('try:\n pass\nexcept*:\n pass', 3, 8)

check('try:\n pass\nexcept*:\n pass\nexcept* ValueError:\n pass', 3, 8)

# Errors thrown by the tokenizer

check('(0x+1)', 1, 3)

check('x = 0xI', 1, 6)

check('0010 + 2', 1, 1)

check('x = 32e-+4', 1, 8)

check('x = 0o9', 1, 7)

check('\u03b1 = 0xI', 1, 6)

check(b'\xce\xb1 = 0xI', 1, 6)

check(b'# -*- coding: iso8859-7 -*-\n\xe1 = 0xI', 2, 6,

encoding='iso8859-7')

check(b"""if 1:

def foo():

'''

def bar():

pass

def baz():

'''quux'''

""", 9, 24)

check("pass\npass\npass\n(1+)\npass\npass\npass", 4, 4)

check("(1+)", 1, 4)

check("[interesting\nfoo()\n", 1, 1)

check(b"\xef\xbb\xbf#coding: utf8\nprint('\xe6\x88\x91')\n", 1, 0)

check("""f'''

{

(123_a)

}'''""", 3, 17)

check("""f'''

{

f\"\"\"

{

(123_a)

}

\"\"\"

}'''""", 5, 17)

check('''f"""

{

6

0="""''', 5, 13)

check('b"fooжжж"'.encode(), 1, 1, 1, 10)

# Errors thrown by symtable.c

check('x = [(yield i) for i in range(3)]', 1, 7)

check('def f():\n from _ import *', 2, 17)

check('def f(x, x):\n pass', 1, 10)

check('{i for i in range(5) if (j := 0) for j in range(5)}', 1, 38)

check('def f(x):\n nonlocal x', 2, 3)

check('def f(x):\n x = 1\n global x', 3, 3)

check('nonlocal x', 1, 1)

check('def f():\n global x\n nonlocal x', 2, 3)

# Errors thrown by future.c

check('from __future__ import doesnt_exist', 1, 24)

check('from __future__ import braces', 1, 24)

check('x=1\nfrom __future__ import division', 2, 1)

check('foo(1=2)', 1, 5)

check('def f():\n x, y: int', 2, 3)

check('foo(x for x in range(10), 100)', 1, 5)

check('for 1 in []: pass', 1, 5)

check('(yield i) = 2', 1, 2)

check('def f(*):\n pass', 1, 7)

@unittest.skipIf(INT_MAX >= sys.maxsize, "Downcasting to int is safe for col_offset")

@support.requires_resource('cpu')

@support.bigmemtest(INT_MAX, memuse=2, dry_run=False)

def testMemoryErrorBigSource(self, size):

src = b"if True:\n%*s" % (size, b"pass")

with self.assertRaisesRegex(OverflowError, "Parser column offset overflow"):

compile(src, '<fragment>', 'exec')

@cpython_only

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

@unittest.skipIf(_testcapi is None, "requires _testcapi")

def test_capi1():

try:

_testcapi.raise_exception(BadException, 1)

except TypeError as err:

co = err.__traceback__.tb_frame.f_code

self.assertEqual(co.co_name, "test_capi1")

self.assertEndsWith(co.co_filename, 'test_exceptions.py')

else:

self.fail("Expected exception")

@unittest.skipIf(_testcapi is None, "requires _testcapi")

def test_capi2():

try:

_testcapi.raise_exception(BadException, 0)

except RuntimeError as err:

tb = err.__traceback__.tb_next

co = tb.tb_frame.f_code

self.assertEqual(co.co_name, "__init__")

self.assertEndsWith(co.co_filename, 'test_exceptions.py')

co2 = tb.tb_frame.f_back.f_code

self.assertEqual(co2.co_name, "test_capi2")

else:

self.fail("Expected exception")

@unittest.skipIf(_testcapi is None, "requires _testcapi")

def test_capi3():

self.assertRaises(SystemError, _testcapi.raise_exception,

InvalidException, 1)

test_capi1()

test_capi2()

test_capi3()

def test_WindowsError(self):

try:

WindowsError

except NameError:

pass

else:

self.assertIs(WindowsError, OSError)

self.assertEqual(str(OSError(1001)), "1001")

self.assertEqual(str(OSError(1001, "message")),

"[Errno 1001] message")

# POSIX errno (9 aka EBADF) is untranslated

w = OSError(9, 'foo', 'bar')

self.assertEqual(w.errno, 9)

self.assertEqual(w.winerror, None)

self.assertEqual(str(w), "[Errno 9] foo: 'bar'")

# ERROR_PATH_NOT_FOUND (win error 3) becomes ENOENT (2)

w = OSError(0, 'foo', 'bar', 3)

self.assertEqual(w.errno, 2)

self.assertEqual(w.winerror, 3)

self.assertEqual(w.strerror, 'foo')

self.assertEqual(w.filename, 'bar')

self.assertEqual(w.filename2, None)

self.assertEqual(str(w), "[WinError 3] foo: 'bar'")

# Unknown win error becomes EINVAL (22)

w = OSError(0, 'foo', None, 1001)

self.assertEqual(w.errno, 22)

self.assertEqual(w.winerror, 1001)

self.assertEqual(w.strerror, 'foo')

self.assertEqual(w.filename, None)

self.assertEqual(w.filename2, None)

self.assertEqual(str(w), "[WinError 1001] foo")

# Non-numeric "errno"

w = OSError('bar', 'foo')

self.assertEqual(w.errno, 'bar')

self.assertEqual(w.winerror, None)

self.assertEqual(w.strerror, 'foo')

self.assertEqual(w.filename, None)

self.assertEqual(w.filename2, None)

@unittest.skipUnless(sys.platform == 'win32',

'test specific to Windows')

def test_windows_message(self):

"""Should fill in unknown error code in Windows error message"""

ctypes = import_module('ctypes')

import ctypes.util # noqa: F811

@ctypes.util.wrap_dll_function(ctypes.pythonapi)

def PyErr_SetFromWindowsErr(ierr: ctypes.c_int) -> ctypes.py_object:

pass

# this error code has no message, Python formats it as hexadecimal

code = 3765269347

with self.assertRaisesRegex(OSError, f'Windows Error 0x{code:x}'):

PyErr_SetFromWindowsErr(code)

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'}),

(OSError, ('foo',), {},

{'args' : ('foo',), 'filename' : None, 'filename2' : None,

'errno' : None, 'strerror' : None}),

(OSError, ('foo', 'bar'), {},

{'args' : ('foo', 'bar'),

'filename' : None, 'filename2' : None,

'errno' : 'foo', 'strerror' : 'bar'}),

(OSError, ('foo', 'bar', 'baz'), {},

{'args' : ('foo', 'bar'),

'filename' : 'baz', 'filename2' : None,

'errno' : 'foo', 'strerror' : 'bar'}),

(OSError, ('foo', 'bar', 'baz', None, 'quux'), {},

{'args' : ('foo', 'bar'), 'filename' : 'baz', 'filename2': 'quux'}),

(OSError, ('errnoStr', 'strErrorStr', 'filenameStr'), {},

{'args' : ('errnoStr', 'strErrorStr'),

'strerror' : 'strErrorStr', 'errno' : 'errnoStr',

'filename' : 'filenameStr'}),

(OSError, (1, 'strErrorStr', 'filenameStr'), {},

{'args' : (1, 'strErrorStr'), 'errno' : 1,

'strerror' : 'strErrorStr',

'filename' : 'filenameStr', 'filename2' : None}),

(SyntaxError, (), {}, {'msg' : None, 'text' : None,

'filename' : None, 'lineno' : None, 'offset' : None,

'end_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,

'end_offset': None}),

(SyntaxError, ('msgStr', ('filenameStr', 'linenoStr', 'offsetStr',

'textStr', 'endLinenoStr', 'endOffsetStr')), {},

{'offset' : 'offsetStr', 'text' : 'textStr',

'args' : ('msgStr', ('filenameStr', 'linenoStr',

'offsetStr', 'textStr',

'endLinenoStr', 'endOffsetStr')),

'print_file_and_line' : None, 'msg' : 'msgStr',

'filename' : 'filenameStr', 'lineno' : 'linenoStr',

'end_lineno': 'endLinenoStr', 'end_offset': 'endOffsetStr'}),

(SyntaxError, ('msgStr', 'filenameStr', 'linenoStr', 'offsetStr',

'textStr', 'endLinenoStr', 'endOffsetStr',

'print_file_and_lineStr'), {},

{'text' : None,

'args' : ('msgStr', 'filenameStr', 'linenoStr', 'offsetStr',

'textStr', 'endLinenoStr', 'endOffsetStr',

'print_file_and_lineStr'),

'print_file_and_line' : None, 'msg' : 'msgStr',

'filename' : None, 'lineno' : None, 'offset' : None,

'end_lineno': None, 'end_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}),

(NaiveException, ('foo',), {},

{'args': ('foo',), 'x': 'foo'}),

(SlottedNaiveException, ('foo',), {},

{'args': ('foo',), 'x': 'foo'}),

(AttributeError, ('foo',), dict(name='name', obj='obj'),

dict(args=('foo',), name='name', obj='obj')),

]

try:

# More tests are in test_WindowsError

exceptionList.append(

(WindowsError, (1, 'strErrorStr', 'filenameStr'), {},

{'args' : (1, 'strErrorStr'),

'strerror' : 'strErrorStr', 'winerror' : None,

'errno' : 1,

'filename' : 'filenameStr', 'filename2' : None})

)

except NameError:

pass

for exc, args, kwargs, expected in exceptionList:

try:

e = exc(*args, **kwargs)

except:

print(f"\nexc={exc!r}, args={args!r}", file=sys.stderr)

# raise

else:

# Verify module name

if not type(e).__name__.endswith('NaiveException'):

self.assertEqual(type(e).__module__, 'builtins')

# Verify no ref leaks in Exc_str()

s = str(e)

for checkArgName in expected:

value = getattr(e, checkArgName)

self.assertEqual(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))

if exc == AttributeError and checkArgName == 'obj':

# See GH-103352, we're not pickling

# obj at this point. So verify it's None.

want = repr(None)

else:

want = repr(expected[checkArgName])

self.assertEqual(got, want,

'pickled "%r", attribute "%s' %

(e, checkArgName))

def test_setstate(self):

e = Exception(42)

e.blah = 53

self.assertEqual(e.args, (42,))

self.assertEqual(e.blah, 53)

self.assertRaises(AttributeError, getattr, e, 'a')

self.assertRaises(AttributeError, getattr, e, 'b')

e.__setstate__({'a': 1 , 'b': 2})

self.assertEqual(e.args, (42,))

self.assertEqual(e.blah, 53)

self.assertEqual(e.a, 1)

self.assertEqual(e.b, 2)

e.__setstate__({'a': 11, 'args': (1,2,3), 'blah': 35})

self.assertEqual(e.args, (1,2,3))

self.assertEqual(e.blah, 35)

self.assertEqual(e.a, 11)

self.assertEqual(e.b, 2)

def test_invalid_setstate(self):

e = Exception(42)

with self.assertRaisesRegex(TypeError, "state is not a dictionary"):

e.__setstate__(42)

def test_notes(self):

for e in [BaseException(1), Exception(2), ValueError(3)]:

with self.subTest(e=e):

self.assertNotHasAttr(e, '__notes__')

e.add_note("My Note")

self.assertEqual(e.__notes__, ["My Note"])

with self.assertRaises(TypeError):

e.add_note(42)

self.assertEqual(e.__notes__, ["My Note"])

e.add_note("Your Note")

self.assertEqual(e.__notes__, ["My Note", "Your Note"])

del e.__notes__

self.assertNotHasAttr(e, '__notes__')

e.add_note("Our Note")

self.assertEqual(e.__notes__, ["Our Note"])

e.__notes__ = 42

self.assertEqual(e.__notes__, 42)

with self.assertRaises(TypeError):

e.add_note("will not work")

self.assertEqual(e.__notes__, 42)

def testWithTraceback(self):

try:

raise IndexError(4)

except Exception as e:

tb = e.__traceback__

e = BaseException().with_traceback(tb)

self.assertIsInstance(e, BaseException)

self.assertEqual(e.__traceback__, tb)

e = IndexError(5).with_traceback(tb)

self.assertIsInstance(e, IndexError)

self.assertEqual(e.__traceback__, tb)

class MyException(Exception):

pass

e = MyException().with_traceback(tb)

self.assertIsInstance(e, MyException)

self.assertEqual(e.__traceback__, tb)

def testInvalidTraceback(self):

try:

Exception().__traceback__ = 5

except TypeError as e:

self.assertIn("__traceback__ must be a traceback", str(e))

else:

self.fail("No exception raised")

def test_invalid_setattr(self):

TE = TypeError

exc = Exception()

msg = "'int' object is not iterable"

self.assertRaisesRegex(TE, msg, setattr, exc, 'args', 1)

msg = "__traceback__ must be a traceback or None"

self.assertRaisesRegex(TE, msg, setattr, exc, '__traceback__', 1)

msg = "exception cause must be None or derive from BaseException"

self.assertRaisesRegex(TE, msg, setattr, exc, '__cause__', 1)

msg = "exception context must be None or derive from BaseException"

self.assertRaisesRegex(TE, msg, setattr, exc, '__context__', 1)

def test_object_attributes(self):

# These attributes are implemented as plain object members:

# they accept any object and are reset to None when deleted.

cases = [

(SyntaxError('msgStr'), 'msg'),

(SyntaxError('msgStr'), 'filename'),

(SyntaxError('msgStr'), 'lineno'),

(SyntaxError('msgStr'), 'offset'),

(SyntaxError('msgStr'), 'end_lineno'),

(SyntaxError('msgStr'), 'end_offset'),

(SyntaxError('msgStr'), 'text'),

(SyntaxError('msgStr'), 'print_file_and_line'),

(SyntaxError('msgStr'), '_metadata'),

(ImportError('msgStr'), 'msg'),

(ImportError('msgStr'), 'name'),

(ImportError('msgStr'), 'path'),

(ImportError('msgStr'), 'name_from'),

(SystemExit(1), 'code'),

(StopIteration(), 'value'),

(NameError('msgStr'), 'name'),

(AttributeError('msgStr'), 'name'),

(AttributeError('msgStr'), 'obj'),

(OSError(2, 'msgStr'), 'errno'),

(OSError(2, 'msgStr'), 'strerror'),

(OSError(2, 'msgStr'), 'filename'),

(OSError(2, 'msgStr'), 'filename2'),

(UnicodeDecodeError('utf-8', b'\xff', 0, 1, 'reasonStr'), 'reason'),

]

if sys.platform == 'win32':

cases.append((OSError(2, 'msgStr'), 'winerror'))

for exc, name in cases:

with self.subTest(exc=type(exc).__name__, name=name):

for value in 'strValue', 42, [1, 2], None:

setattr(exc, name, value)

self.assertEqual(getattr(exc, name), value)

delattr(exc, name)

self.assertIsNone(getattr(exc, name))

def test_invalid_delattr(self):

AE = AttributeError

try:

raise IndexError(4)

except Exception as e:

exc = e

msg = "cannot be deleted"

self.assertRaisesRegex(AE, msg, delattr, exc, 'args')

self.assertRaisesRegex(AE, msg, delattr, exc, '__traceback__')

self.assertRaisesRegex(AE, msg, delattr, exc, '__cause__')

self.assertRaisesRegex(AE, msg, delattr, exc, '__context__')

def testNoneClearsTracebackAttr(self):

try:

raise IndexError(4)

except Exception as e:

tb = e.__traceback__

e = Exception()

e.__traceback__ = tb

e.__traceback__ = None

self.assertEqual(e.__traceback__, None)

def testChainingAttrs(self):

e = Exception()

self.assertIsNone(e.__context__)

self.assertIsNone(e.__cause__)

e = TypeError()

self.assertIsNone(e.__context__)

self.assertIsNone(e.__cause__)

class MyException(OSError):

pass

e = MyException()

self.assertIsNone(e.__context__)

self.assertIsNone(e.__cause__)

def testChainingDescriptors(self):

try:

raise Exception()

except Exception as exc:

e = exc

self.assertIsNone(e.__context__)

self.assertIsNone(e.__cause__)

self.assertFalse(e.__suppress_context__)

e.__context__ = NameError()

e.__cause__ = None

self.assertIsInstance(e.__context__, NameError)

self.assertIsNone(e.__cause__)

self.assertTrue(e.__suppress_context__)

e.__suppress_context__ = False

self.assertFalse(e.__suppress_context__)

with self.assertRaisesRegex(TypeError,

'attribute value type must be bool'):

e.__suppress_context__ = 1

with self.assertRaisesRegex(TypeError,

"can't delete numeric/char attribute"):

del e.__suppress_context__

self.assertFalse(e.__suppress_context__)

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.assertEqual(x.fancy_arg, 42)

@no_tracing

def testInfiniteRecursion(self):

def f():

return f()

self.assertRaises(RecursionError, f)

def g():

try:

return g()

except ValueError:

return -1

self.assertRaises(RecursionError, g)

def test_str(self):

# Make sure both instances and classes have a str representation.

self.assertTrue(str(Exception))

self.assertTrue(str(Exception('a')))

self.assertTrue(str(Exception('a', 'b')))

def test_exception_cleanup_names(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.assertIsInstance(e, Exception)

self.assertNotIn('e', locals())

with self.assertRaises(UnboundLocalError):

e

def test_exception_cleanup_names2(self):

# Make sure the cleanup doesn't break if the variable is explicitly deleted.

try:

raise Exception()

except Exception as e:

self.assertIsInstance(e, Exception)

del e

self.assertNotIn('e', locals())

with self.assertRaises(UnboundLocalError):

e

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

gc_collect() # For PyPy or other GCs.

obj = wr()

self.assertIsNone(obj)

# Qualified "except" without "as"

obj = MyObj()

wr = weakref.ref(obj)

try:

inner_raising_func()

except MyException:

pass

obj = None

gc_collect() # For PyPy or other GCs.

obj = wr()

self.assertIsNone(obj)

# Bare "except"

obj = MyObj()

wr = weakref.ref(obj)

try:

inner_raising_func()

except:

pass

obj = None

gc_collect() # For PyPy or other GCs.

obj = wr()

self.assertIsNone(obj)

# "except" with premature block leave

obj = MyObj()

wr = weakref.ref(obj)

for i in [0]:

try:

inner_raising_func()

except:

break

obj = None

gc_collect() # For PyPy or other GCs.

obj = wr()

self.assertIsNone(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

gc_collect() # For PyPy or other GCs.

obj = wr()

# guarantee no ref cycles on CPython (don't gc_collect)

if check_impl_detail(cpython=False):

gc_collect()

self.assertIsNone(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

if check_impl_detail(cpython=False):

gc_collect()

obj = wr()

self.assertIsNone(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

if check_impl_detail(cpython=False):

gc_collect()

obj = wr()

self.assertIsNone(obj)

def test_exception_target_in_nested_scope(self):

# issue 4617: This used to raise a SyntaxError

# "can not delete variable 'e' referenced in nested scope"

def print_error():

e

try:

something

except Exception as e:

print_error()

# implicit "del e" here