274 lines
9.2 KiB
Python
274 lines
9.2 KiB
Python
# -*- coding: iso-8859-1 -*-
|
|
import unittest, test.test_support
|
|
import sys, cStringIO
|
|
|
|
class SysModuleTest(unittest.TestCase):
|
|
|
|
def test_original_displayhook(self):
|
|
import __builtin__
|
|
savestdout = sys.stdout
|
|
out = cStringIO.StringIO()
|
|
sys.stdout = out
|
|
|
|
dh = sys.__displayhook__
|
|
|
|
self.assertRaises(TypeError, dh)
|
|
if hasattr(__builtin__, "_"):
|
|
del __builtin__._
|
|
|
|
dh(None)
|
|
self.assertEqual(out.getvalue(), "")
|
|
self.assert_(not hasattr(__builtin__, "_"))
|
|
dh(42)
|
|
self.assertEqual(out.getvalue(), "42\n")
|
|
self.assertEqual(__builtin__._, 42)
|
|
|
|
del sys.stdout
|
|
self.assertRaises(RuntimeError, dh, 42)
|
|
|
|
sys.stdout = savestdout
|
|
|
|
def test_lost_displayhook(self):
|
|
olddisplayhook = sys.displayhook
|
|
del sys.displayhook
|
|
code = compile("42", "<string>", "single")
|
|
self.assertRaises(RuntimeError, eval, code)
|
|
sys.displayhook = olddisplayhook
|
|
|
|
def test_custom_displayhook(self):
|
|
olddisplayhook = sys.displayhook
|
|
def baddisplayhook(obj):
|
|
raise ValueError
|
|
sys.displayhook = baddisplayhook
|
|
code = compile("42", "<string>", "single")
|
|
self.assertRaises(ValueError, eval, code)
|
|
sys.displayhook = olddisplayhook
|
|
|
|
def test_original_excepthook(self):
|
|
savestderr = sys.stderr
|
|
err = cStringIO.StringIO()
|
|
sys.stderr = err
|
|
|
|
eh = sys.__excepthook__
|
|
|
|
self.assertRaises(TypeError, eh)
|
|
try:
|
|
raise ValueError(42)
|
|
except ValueError, exc:
|
|
eh(*sys.exc_info())
|
|
|
|
sys.stderr = savestderr
|
|
self.assert_(err.getvalue().endswith("ValueError: 42\n"))
|
|
|
|
# FIXME: testing the code for a lost or replaced excepthook in
|
|
# Python/pythonrun.c::PyErr_PrintEx() is tricky.
|
|
|
|
def test_exc_clear(self):
|
|
self.assertRaises(TypeError, sys.exc_clear, 42)
|
|
|
|
# Verify that exc_info is present and matches exc, then clear it, and
|
|
# check that it worked.
|
|
def clear_check(exc):
|
|
typ, value, traceback = sys.exc_info()
|
|
self.assert_(typ is not None)
|
|
self.assert_(value is exc)
|
|
self.assert_(traceback is not None)
|
|
|
|
sys.exc_clear()
|
|
|
|
typ, value, traceback = sys.exc_info()
|
|
self.assert_(typ is None)
|
|
self.assert_(value is None)
|
|
self.assert_(traceback is None)
|
|
|
|
def clear():
|
|
try:
|
|
raise ValueError, 42
|
|
except ValueError, exc:
|
|
clear_check(exc)
|
|
|
|
# Raise an exception and check that it can be cleared
|
|
clear()
|
|
|
|
# Verify that a frame currently handling an exception is
|
|
# unaffected by calling exc_clear in a nested frame.
|
|
try:
|
|
raise ValueError, 13
|
|
except ValueError, exc:
|
|
typ1, value1, traceback1 = sys.exc_info()
|
|
clear()
|
|
typ2, value2, traceback2 = sys.exc_info()
|
|
|
|
self.assert_(typ1 is typ2)
|
|
self.assert_(value1 is exc)
|
|
self.assert_(value1 is value2)
|
|
self.assert_(traceback1 is traceback2)
|
|
|
|
# Check that an exception can be cleared outside of an except block
|
|
clear_check(exc)
|
|
|
|
def test_exit(self):
|
|
self.assertRaises(TypeError, sys.exit, 42, 42)
|
|
|
|
# call without argument
|
|
try:
|
|
sys.exit(0)
|
|
except SystemExit, exc:
|
|
self.assertEquals(exc.code, 0)
|
|
except:
|
|
self.fail("wrong exception")
|
|
else:
|
|
self.fail("no exception")
|
|
|
|
# call with tuple argument with one entry
|
|
# entry will be unpacked
|
|
try:
|
|
sys.exit(42)
|
|
except SystemExit, exc:
|
|
self.assertEquals(exc.code, 42)
|
|
except:
|
|
self.fail("wrong exception")
|
|
else:
|
|
self.fail("no exception")
|
|
|
|
# call with integer argument
|
|
try:
|
|
sys.exit((42,))
|
|
except SystemExit, exc:
|
|
self.assertEquals(exc.code, 42)
|
|
except:
|
|
self.fail("wrong exception")
|
|
else:
|
|
self.fail("no exception")
|
|
|
|
# call with string argument
|
|
try:
|
|
sys.exit("exit")
|
|
except SystemExit, exc:
|
|
self.assertEquals(exc.code, "exit")
|
|
except:
|
|
self.fail("wrong exception")
|
|
else:
|
|
self.fail("no exception")
|
|
|
|
# call with tuple argument with two entries
|
|
try:
|
|
sys.exit((17, 23))
|
|
except SystemExit, exc:
|
|
self.assertEquals(exc.code, (17, 23))
|
|
except:
|
|
self.fail("wrong exception")
|
|
else:
|
|
self.fail("no exception")
|
|
|
|
# test that the exit machinery handles SystemExits properly
|
|
import subprocess
|
|
# both unnormalized...
|
|
rc = subprocess.call([sys.executable, "-c",
|
|
"raise SystemExit, 46"])
|
|
self.assertEqual(rc, 46)
|
|
# ... and normalized
|
|
rc = subprocess.call([sys.executable, "-c",
|
|
"raise SystemExit(47)"])
|
|
self.assertEqual(rc, 47)
|
|
|
|
|
|
def test_getdefaultencoding(self):
|
|
if test.test_support.have_unicode:
|
|
self.assertRaises(TypeError, sys.getdefaultencoding, 42)
|
|
# can't check more than the type, as the user might have changed it
|
|
self.assert_(isinstance(sys.getdefaultencoding(), str))
|
|
|
|
# testing sys.settrace() is done in test_trace.py
|
|
# testing sys.setprofile() is done in test_profile.py
|
|
|
|
def test_setcheckinterval(self):
|
|
self.assertRaises(TypeError, sys.setcheckinterval)
|
|
orig = sys.getcheckinterval()
|
|
for n in 0, 100, 120, orig: # orig last to restore starting state
|
|
sys.setcheckinterval(n)
|
|
self.assertEquals(sys.getcheckinterval(), n)
|
|
|
|
def test_recursionlimit(self):
|
|
self.assertRaises(TypeError, sys.getrecursionlimit, 42)
|
|
oldlimit = sys.getrecursionlimit()
|
|
self.assertRaises(TypeError, sys.setrecursionlimit)
|
|
self.assertRaises(ValueError, sys.setrecursionlimit, -42)
|
|
sys.setrecursionlimit(10000)
|
|
self.assertEqual(sys.getrecursionlimit(), 10000)
|
|
sys.setrecursionlimit(oldlimit)
|
|
|
|
def test_getwindowsversion(self):
|
|
if hasattr(sys, "getwindowsversion"):
|
|
v = sys.getwindowsversion()
|
|
self.assert_(isinstance(v, tuple))
|
|
self.assertEqual(len(v), 5)
|
|
self.assert_(isinstance(v[0], int))
|
|
self.assert_(isinstance(v[1], int))
|
|
self.assert_(isinstance(v[2], int))
|
|
self.assert_(isinstance(v[3], int))
|
|
self.assert_(isinstance(v[4], str))
|
|
|
|
def test_dlopenflags(self):
|
|
if hasattr(sys, "setdlopenflags"):
|
|
self.assert_(hasattr(sys, "getdlopenflags"))
|
|
self.assertRaises(TypeError, sys.getdlopenflags, 42)
|
|
oldflags = sys.getdlopenflags()
|
|
self.assertRaises(TypeError, sys.setdlopenflags)
|
|
sys.setdlopenflags(oldflags+1)
|
|
self.assertEqual(sys.getdlopenflags(), oldflags+1)
|
|
sys.setdlopenflags(oldflags)
|
|
|
|
def test_refcount(self):
|
|
self.assertRaises(TypeError, sys.getrefcount)
|
|
c = sys.getrefcount(None)
|
|
n = None
|
|
self.assertEqual(sys.getrefcount(None), c+1)
|
|
del n
|
|
self.assertEqual(sys.getrefcount(None), c)
|
|
if hasattr(sys, "gettotalrefcount"):
|
|
self.assert_(isinstance(sys.gettotalrefcount(), int))
|
|
|
|
def test_getframe(self):
|
|
self.assertRaises(TypeError, sys._getframe, 42, 42)
|
|
self.assertRaises(ValueError, sys._getframe, 2000000000)
|
|
self.assert_(
|
|
SysModuleTest.test_getframe.im_func.func_code \
|
|
is sys._getframe().f_code
|
|
)
|
|
|
|
def test_attributes(self):
|
|
self.assert_(isinstance(sys.api_version, int))
|
|
self.assert_(isinstance(sys.argv, list))
|
|
self.assert_(sys.byteorder in ("little", "big"))
|
|
self.assert_(isinstance(sys.builtin_module_names, tuple))
|
|
self.assert_(isinstance(sys.copyright, basestring))
|
|
self.assert_(isinstance(sys.exec_prefix, basestring))
|
|
self.assert_(isinstance(sys.executable, basestring))
|
|
self.assert_(isinstance(sys.hexversion, int))
|
|
self.assert_(isinstance(sys.maxint, int))
|
|
if test.test_support.have_unicode:
|
|
self.assert_(isinstance(sys.maxunicode, int))
|
|
self.assert_(isinstance(sys.platform, basestring))
|
|
self.assert_(isinstance(sys.prefix, basestring))
|
|
self.assert_(isinstance(sys.version, basestring))
|
|
vi = sys.version_info
|
|
self.assert_(isinstance(vi, tuple))
|
|
self.assertEqual(len(vi), 5)
|
|
self.assert_(isinstance(vi[0], int))
|
|
self.assert_(isinstance(vi[1], int))
|
|
self.assert_(isinstance(vi[2], int))
|
|
self.assert_(vi[3] in ("alpha", "beta", "candidate", "final"))
|
|
self.assert_(isinstance(vi[4], int))
|
|
|
|
def test_43581(self):
|
|
# Can't use sys.stdout, as this is a cStringIO object when
|
|
# the test runs under regrtest.
|
|
self.assert_(sys.__stdout__.encoding == sys.__stderr__.encoding)
|
|
|
|
def test_main():
|
|
test.test_support.run_unittest(SysModuleTest)
|
|
|
|
if __name__ == "__main__":
|
|
test_main()
|