261 lines
9.4 KiB
Python
261 lines
9.4 KiB
Python
"""Test cases for traceback module"""
|
|
|
|
from StringIO import StringIO
|
|
import sys
|
|
import unittest
|
|
from imp import reload
|
|
from test.test_support import (run_unittest, is_jython, Error, cpython_only,
|
|
captured_output)
|
|
|
|
import traceback
|
|
|
|
|
|
class TracebackCases(unittest.TestCase):
|
|
# For now, a very minimal set of tests. I want to be sure that
|
|
# formatting of SyntaxErrors works based on changes for 2.1.
|
|
|
|
def get_exception_format(self, func, exc):
|
|
try:
|
|
func()
|
|
except exc, value:
|
|
return traceback.format_exception_only(exc, value)
|
|
else:
|
|
raise ValueError, "call did not raise exception"
|
|
|
|
def syntax_error_with_caret(self):
|
|
compile("def fact(x):\n\treturn x!\n", "?", "exec")
|
|
|
|
def syntax_error_with_caret_2(self):
|
|
compile("1 +\n", "?", "exec")
|
|
|
|
def syntax_error_without_caret(self):
|
|
# XXX why doesn't compile raise the same traceback?
|
|
import test.badsyntax_nocaret
|
|
|
|
def syntax_error_bad_indentation(self):
|
|
compile("def spam():\n print 1\n print 2", "?", "exec")
|
|
|
|
def syntax_error_bad_indentation2(self):
|
|
compile(" print(2)", "?", "exec")
|
|
|
|
def test_caret(self):
|
|
err = self.get_exception_format(self.syntax_error_with_caret,
|
|
SyntaxError)
|
|
self.assertTrue(len(err) == 4)
|
|
self.assertTrue(err[1].strip() == "return x!")
|
|
self.assertIn("^", err[2]) # third line has caret
|
|
self.assertTrue(err[1].find("!") == err[2].find("^")) # in the right place
|
|
|
|
err = self.get_exception_format(self.syntax_error_with_caret_2,
|
|
SyntaxError)
|
|
self.assertIn("^", err[2]) # third line has caret
|
|
self.assertTrue(err[2].count('\n') == 1) # and no additional newline
|
|
self.assertTrue(err[1].find("+") == err[2].find("^")) # in the right place
|
|
|
|
def test_nocaret(self):
|
|
if is_jython:
|
|
# jython adds a caret in this case (why shouldn't it?)
|
|
return
|
|
err = self.get_exception_format(self.syntax_error_without_caret,
|
|
SyntaxError)
|
|
self.assertTrue(len(err) == 3)
|
|
self.assertTrue(err[1].strip() == "[x for x in x] = x")
|
|
|
|
def test_bad_indentation(self):
|
|
err = self.get_exception_format(self.syntax_error_bad_indentation,
|
|
IndentationError)
|
|
self.assertTrue(len(err) == 4)
|
|
self.assertTrue(err[1].strip() == "print 2")
|
|
self.assertIn("^", err[2])
|
|
self.assertTrue(err[1].find("2") == err[2].find("^"))
|
|
|
|
def test_bug737473(self):
|
|
import os, tempfile, time
|
|
|
|
savedpath = sys.path[:]
|
|
testdir = tempfile.mkdtemp()
|
|
try:
|
|
sys.path.insert(0, testdir)
|
|
testfile = os.path.join(testdir, 'test_bug737473.py')
|
|
print >> open(testfile, 'w'), """
|
|
def test():
|
|
raise ValueError"""
|
|
|
|
if 'test_bug737473' in sys.modules:
|
|
del sys.modules['test_bug737473']
|
|
import test_bug737473
|
|
|
|
try:
|
|
test_bug737473.test()
|
|
except ValueError:
|
|
# this loads source code to linecache
|
|
traceback.extract_tb(sys.exc_traceback)
|
|
|
|
# If this test runs too quickly, test_bug737473.py's mtime
|
|
# attribute will remain unchanged even if the file is rewritten.
|
|
# Consequently, the file would not reload. So, added a sleep()
|
|
# delay to assure that a new, distinct timestamp is written.
|
|
# Since WinME with FAT32 has multisecond resolution, more than
|
|
# three seconds are needed for this test to pass reliably :-(
|
|
time.sleep(4)
|
|
|
|
print >> open(testfile, 'w'), """
|
|
def test():
|
|
raise NotImplementedError"""
|
|
reload(test_bug737473)
|
|
try:
|
|
test_bug737473.test()
|
|
except NotImplementedError:
|
|
src = traceback.extract_tb(sys.exc_traceback)[-1][-1]
|
|
self.assertEqual(src, 'raise NotImplementedError')
|
|
finally:
|
|
sys.path[:] = savedpath
|
|
for f in os.listdir(testdir):
|
|
os.unlink(os.path.join(testdir, f))
|
|
os.rmdir(testdir)
|
|
|
|
err = self.get_exception_format(self.syntax_error_bad_indentation2,
|
|
IndentationError)
|
|
self.assertEqual(len(err), 4)
|
|
self.assertEqual(err[1].strip(), "print(2)")
|
|
self.assertIn("^", err[2])
|
|
self.assertEqual(err[1].find("p"), err[2].find("^"))
|
|
|
|
def test_base_exception(self):
|
|
# Test that exceptions derived from BaseException are formatted right
|
|
e = KeyboardInterrupt()
|
|
lst = traceback.format_exception_only(e.__class__, e)
|
|
self.assertEqual(lst, ['KeyboardInterrupt\n'])
|
|
|
|
# String exceptions are deprecated, but legal. The quirky form with
|
|
# separate "type" and "value" tends to break things, because
|
|
# not isinstance(value, type)
|
|
# and a string cannot be the first argument to issubclass.
|
|
#
|
|
# Note that sys.last_type and sys.last_value do not get set if an
|
|
# exception is caught, so we sort of cheat and just emulate them.
|
|
#
|
|
# test_string_exception1 is equivalent to
|
|
#
|
|
# >>> raise "String Exception"
|
|
#
|
|
# test_string_exception2 is equivalent to
|
|
#
|
|
# >>> raise "String Exception", "String Value"
|
|
#
|
|
def test_string_exception1(self):
|
|
str_type = "String Exception"
|
|
err = traceback.format_exception_only(str_type, None)
|
|
self.assertEqual(len(err), 1)
|
|
self.assertEqual(err[0], str_type + '\n')
|
|
|
|
def test_string_exception2(self):
|
|
str_type = "String Exception"
|
|
str_value = "String Value"
|
|
err = traceback.format_exception_only(str_type, str_value)
|
|
self.assertEqual(len(err), 1)
|
|
self.assertEqual(err[0], str_type + ': ' + str_value + '\n')
|
|
|
|
def test_format_exception_only_bad__str__(self):
|
|
class X(Exception):
|
|
def __str__(self):
|
|
1 // 0
|
|
err = traceback.format_exception_only(X, X())
|
|
self.assertEqual(len(err), 1)
|
|
str_value = '<unprintable %s object>' % X.__name__
|
|
self.assertEqual(err[0], X.__name__ + ': ' + str_value + '\n')
|
|
|
|
def test_without_exception(self):
|
|
err = traceback.format_exception_only(None, None)
|
|
self.assertEqual(err, ['None\n'])
|
|
|
|
def test_unicode(self):
|
|
err = AssertionError('\xff')
|
|
lines = traceback.format_exception_only(type(err), err)
|
|
self.assertEqual(lines, ['AssertionError: \xff\n'])
|
|
|
|
err = AssertionError(u'\xe9')
|
|
lines = traceback.format_exception_only(type(err), err)
|
|
self.assertEqual(lines, ['AssertionError: \\xe9\n'])
|
|
|
|
|
|
class TracebackFormatTests(unittest.TestCase):
|
|
|
|
@cpython_only
|
|
def test_traceback_format(self):
|
|
from _testcapi import traceback_print
|
|
try:
|
|
raise KeyError('blah')
|
|
except KeyError:
|
|
type_, value, tb = sys.exc_info()
|
|
traceback_fmt = 'Traceback (most recent call last):\n' + \
|
|
''.join(traceback.format_tb(tb))
|
|
file_ = StringIO()
|
|
traceback_print(tb, file_)
|
|
python_fmt = file_.getvalue()
|
|
else:
|
|
raise Error("unable to create test traceback string")
|
|
|
|
# Make sure that Python and the traceback module format the same thing
|
|
self.assertEqual(traceback_fmt, python_fmt)
|
|
|
|
# Make sure that the traceback is properly indented.
|
|
tb_lines = python_fmt.splitlines()
|
|
self.assertEqual(len(tb_lines), 3)
|
|
banner, location, source_line = tb_lines
|
|
self.assertTrue(banner.startswith('Traceback'))
|
|
self.assertTrue(location.startswith(' File'))
|
|
self.assertTrue(source_line.startswith(' raise'))
|
|
|
|
def test_print_stack(self):
|
|
def prn():
|
|
traceback.print_stack()
|
|
with captured_output("stderr") as stderr:
|
|
prn()
|
|
lineno = prn.__code__.co_firstlineno
|
|
file = prn.__code__.co_filename
|
|
self.assertEqual(stderr.getvalue().splitlines()[-4:], [
|
|
' File "%s", line %d, in test_print_stack' % (file, lineno+3),
|
|
' prn()',
|
|
' File "%s", line %d, in prn' % (file, lineno+1),
|
|
' traceback.print_stack()',
|
|
])
|
|
|
|
def test_format_stack(self):
|
|
def fmt():
|
|
return traceback.format_stack()
|
|
result = fmt()
|
|
lineno = fmt.__code__.co_firstlineno
|
|
file = fmt.__code__.co_filename
|
|
self.assertEqual(result[-2:], [
|
|
' File "%s", line %d, in test_format_stack\n'
|
|
' result = fmt()\n' % (file, lineno+2),
|
|
' File "%s", line %d, in fmt\n'
|
|
' return traceback.format_stack()\n' % (file, lineno+1),
|
|
])
|
|
|
|
|
|
class MiscTracebackCases(unittest.TestCase):
|
|
#
|
|
# Check non-printing functions in traceback module
|
|
#
|
|
|
|
def test_extract_stack(self):
|
|
def extract():
|
|
return traceback.extract_stack()
|
|
result = extract()
|
|
lineno = extract.__code__.co_firstlineno
|
|
file = extract.__code__.co_filename
|
|
self.assertEqual(result[-2:], [
|
|
(file, lineno+2, 'test_extract_stack', 'result = extract()'),
|
|
(file, lineno+1, 'extract', 'return traceback.extract_stack()'),
|
|
])
|
|
|
|
|
|
def test_main():
|
|
run_unittest(TracebackCases, TracebackFormatTests, MiscTracebackCases)
|
|
|
|
|
|
if __name__ == "__main__":
|
|
test_main()
|