| """Test cases for traceback module""" |
| |
| from _testcapi import traceback_print |
| from io import StringIO |
| import sys |
| import unittest |
| from test.support import run_unittest, is_jython, Error |
| |
| import traceback |
| |
| try: |
| raise KeyError |
| except KeyError: |
| type_, value, tb = sys.exc_info() |
| file_ = StringIO() |
| traceback_print(tb, file_) |
| example_traceback = file_.getvalue() |
| else: |
| raise Error("unable to create test traceback string") |
| |
| |
| 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 as 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_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 test_caret(self): |
| err = self.get_exception_format(self.syntax_error_with_caret, |
| SyntaxError) |
| self.assertEqual(len(err), 4) |
| self.assert_(err[1].strip() == "return x!") |
| self.assert_("^" in err[2]) # third line has caret |
| self.assertEqual(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.assertEqual(len(err), 3) |
| self.assert_(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.assertEqual(len(err), 4) |
| self.assertEqual(err[1].strip(), "print(2)") |
| self.assert_("^" in err[2]) |
| self.assertEqual(err[1].find(")"), 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']) |
| |
| 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__ |
| if X.__module__ in ('__main__', 'builtins'): |
| str_name = X.__name__ |
| else: |
| str_name = '.'.join([X.__module__, X.__name__]) |
| self.assertEqual(err[0], "%s: %s\n" % (str_name, str_value)) |
| |
| def test_without_exception(self): |
| err = traceback.format_exception_only(None, None) |
| self.assertEqual(err, ['None\n']) |
| |
| |
| class TracebackFormatTests(unittest.TestCase): |
| |
| def test_traceback_indentation(self): |
| # Make sure that the traceback is properly indented. |
| tb_lines = example_traceback.splitlines() |
| self.assertEquals(len(tb_lines), 3) |
| banner, location, source_line = tb_lines |
| self.assert_(banner.startswith('Traceback')) |
| self.assert_(location.startswith(' File')) |
| self.assert_(source_line.startswith('raise')) |
| |
| |
| def test_main(): |
| run_unittest(TracebackCases, TracebackFormatTests) |
| |
| |
| if __name__ == "__main__": |
| test_main() |