| """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() |
