diff -r ffa851df0825 -r 2fb8b9db1c86 symbian-qemu-0.9.1-12/python-2.6.1/Lib/test/test_traceback.py --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/symbian-qemu-0.9.1-12/python-2.6.1/Lib/test/test_traceback.py Fri Jul 31 15:01:17 2009 +0100 @@ -0,0 +1,188 @@ +"""Test cases for traceback module""" + +from _testcapi import traceback_print +from StringIO import StringIO +import sys +import unittest +from test.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, 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.assert_(len(err) == 4) + self.assert_(err[1].strip() == "return x!") + self.assert_("^" in err[2]) # third line has caret + self.assert_(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.assert_(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.assert_(len(err) == 4) + self.assert_(err[1].strip() == "print 2") + self.assert_("^" in err[2]) + self.assert_(err[1].find("2") == err[2].find("^")) + + def test_bug737473(self): + import sys, 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.failUnlessEqual(src, 'raise NotImplementedError') + finally: + sys.path[:] = savedpath + for f in os.listdir(testdir): + os.unlink(os.path.join(testdir, f)) + os.rmdir(testdir) + + def test_members(self): + # Covers Python/structmember.c::listmembers() + try: + 1/0 + except: + import sys + sys.exc_traceback.__members__ + + 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 = '' % 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']) + + +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()