Lib/test/test_traceback.py

   1 """Test cases for traceback module"""
   2
   3 from _testcapi import traceback_print
   4 from StringIO import StringIO
   5 import sys
   6 import unittest
   7 from test.test_support import run_unittest, is_jython, Error
   8
   9 import traceback
  10
  11 try:
  12     raise KeyError
  13 except KeyError:
  14     type_, value, tb = sys.exc_info()
  15     file_ = StringIO()
  16     traceback_print(tb, file_)
  17     example_traceback = file_.getvalue()
  18 else:
  19     raise Error("unable to create test traceback string")
  20
  21
  22 class TracebackCases(unittest.TestCase):
  23     # For now, a very minimal set of tests.  I want to be sure that
  24     # formatting of SyntaxErrors works based on changes for 2.1.
  25
  26     def get_exception_format(self, func, exc):
  27         try:
  28             func()
  29         except exc, value:
  30             return traceback.format_exception_only(exc, value)
  31         else:
  32             raise ValueError, "call did not raise exception"
  33
  34     def syntax_error_with_caret(self):
  35         compile("def fact(x):\n\treturn x!\n", "?", "exec")
  36
  37     def syntax_error_without_caret(self):
  38         # XXX why doesn't compile raise the same traceback?
  39         import test.badsyntax_nocaret
  40
  41     def syntax_error_bad_indentation(self):
  42         compile("def spam():\n  print 1\n print 2", "?", "exec")
  43
  44     def test_caret(self):
  45         err = self.get_exception_format(self.syntax_error_with_caret,
  46                                         SyntaxError)
  47         self.assert_(len(err) == 4)
  48         self.assert_(err[1].strip() == "return x!")
  49         self.assert_("^" in err[2]) # third line has caret
  50         self.assert_(err[1].find("!") == err[2].find("^")) # in the right place
  51
  52     def test_nocaret(self):
  53         if is_jython:
  54             # jython adds a caret in this case (why shouldn't it?)
  55             return
  56         err = self.get_exception_format(self.syntax_error_without_caret,
  57                                         SyntaxError)
  58         self.assert_(len(err) == 3)
  59         self.assert_(err[1].strip() == "[x for x in x] = x")
  60
  61     def test_bad_indentation(self):
  62         err = self.get_exception_format(self.syntax_error_bad_indentation,
  63                                         IndentationError)
  64         self.assert_(len(err) == 4)
  65         self.assert_(err[1].strip() == "print 2")
  66         self.assert_("^" in err[2])
  67         self.assert_(err[1].find("2") == err[2].find("^"))
  68
  69     def test_bug737473(self):
  70         import sys, os, tempfile, time
  71
  72         savedpath = sys.path[:]
  73         testdir = tempfile.mkdtemp()
  74         try:
  75             sys.path.insert(0, testdir)
  76             testfile = os.path.join(testdir, 'test_bug737473.py')
  77             print >> open(testfile, 'w'), """
  78 def test():
  79     raise ValueError"""
  80
  81             if 'test_bug737473' in sys.modules:
  82                 del sys.modules['test_bug737473']
  83             import test_bug737473
  84
  85             try:
  86                 test_bug737473.test()
  87             except ValueError:
  88                 # this loads source code to linecache
  89                 traceback.extract_tb(sys.exc_traceback)
  90
  91             # If this test runs too quickly, test_bug737473.py's mtime
  92             # attribute will remain unchanged even if the file is rewritten.
  93             # Consequently, the file would not reload.  So, added a sleep()
  94             # delay to assure that a new, distinct timestamp is written.
  95             # Since WinME with FAT32 has multisecond resolution, more than
  96             # three seconds are needed for this test to pass reliably :-(
  97             time.sleep(4)
  98
  99             print >> open(testfile, 'w'), """
 100 def test():
 101     raise NotImplementedError"""
 102             reload(test_bug737473)
 103             try:
 104                 test_bug737473.test()
 105             except NotImplementedError:
 106                 src = traceback.extract_tb(sys.exc_traceback)[-1][-1]
 107                 self.failUnlessEqual(src, 'raise NotImplementedError')
 108         finally:
 109             sys.path[:] = savedpath
 110             for f in os.listdir(testdir):
 111                 os.unlink(os.path.join(testdir, f))
 112             os.rmdir(testdir)
 113
 114     def test_members(self):
 115         # Covers Python/structmember.c::listmembers()
 116         try:
 117             1/0
 118         except:
 119             import sys
 120             sys.exc_traceback.__members__
 121
 122     def test_base_exception(self):
 123         # Test that exceptions derived from BaseException are formatted right
 124         e = KeyboardInterrupt()
 125         lst = traceback.format_exception_only(e.__class__, e)
 126         self.assertEqual(lst, ['KeyboardInterrupt\n'])
 127
 128     # String exceptions are deprecated, but legal.  The quirky form with
 129     # separate "type" and "value" tends to break things, because
 130     #     not isinstance(value, type)
 131     # and a string cannot be the first argument to issubclass.
 132     #
 133     # Note that sys.last_type and sys.last_value do not get set if an
 134     # exception is caught, so we sort of cheat and just emulate them.
 135     #
 136     # test_string_exception1 is equivalent to
 137     #
 138     # >>> raise "String Exception"
 139     #
 140     # test_string_exception2 is equivalent to
 141     #
 142     # >>> raise "String Exception", "String Value"
 143     #
 144     def test_string_exception1(self):
 145         str_type = "String Exception"
 146         err = traceback.format_exception_only(str_type, None)
 147         self.assertEqual(len(err), 1)
 148         self.assertEqual(err[0], str_type + '\n')
 149
 150     def test_string_exception2(self):
 151         str_type = "String Exception"
 152         str_value = "String Value"
 153         err = traceback.format_exception_only(str_type, str_value)
 154         self.assertEqual(len(err), 1)
 155         self.assertEqual(err[0], str_type + ': ' + str_value + '\n')
 156
 157     def test_format_exception_only_bad__str__(self):
 158         class X(Exception):
 159             def __str__(self):
 160                 1/0
 161         err = traceback.format_exception_only(X, X())
 162         self.assertEqual(len(err), 1)
 163         str_value = '<unprintable %s object>' % X.__name__
 164         self.assertEqual(err[0], X.__name__ + ': ' + str_value + '\n')
 165
 166     def test_without_exception(self):
 167         err = traceback.format_exception_only(None, None)
 168         self.assertEqual(err, ['None\n'])
 169
 170
 171 class TracebackFormatTests(unittest.TestCase):
 172
 173     def test_traceback_indentation(self):
 174         # Make sure that the traceback is properly indented.
 175         tb_lines = example_traceback.splitlines()
 176         self.assertEquals(len(tb_lines), 3)
 177         banner, location, source_line = tb_lines
 178         self.assert_(banner.startswith('Traceback'))
 179         self.assert_(location.startswith('  File'))
 180         self.assert_(source_line.startswith('    raise'))
 181
 182
 183 def test_main():
 184     run_unittest(TracebackCases, TracebackFormatTests)
 185
 186
 187 if __name__ == "__main__":
 188     test_main()