home *** CD-ROM | disk | FTP | other *** search
/ Maximum CD 2011 June / maximum-cd-2011-06.iso / DiscContents / LibO_3.3.1_Win_x86_install_multi.exe / libreoffice1.cab / test_traceback.py < prev    next >
Encoding:
Python Source  |  2011-02-15  |  6.5 KB  |  189 lines
  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()
  189.