1 # -*- coding: iso-8859-1 -*-

     2 import unittest, test.test_support

     3 import sys, cStringIO

     4 

     5 class SysModuleTest(unittest.TestCase):

     6 

     7     def test_original_displayhook(self):

     8         import __builtin__

     9         savestdout = sys.stdout

    10         out = cStringIO.StringIO()

    11         sys.stdout = out

    12 

    13         dh = sys.__displayhook__

    14 

    15         self.assertRaises(TypeError, dh)

    16         if hasattr(__builtin__, "_"):

    17             del __builtin__._

    18 

    19         dh(None)

    20         self.assertEqual(out.getvalue(), "")

    21         self.assert_(not hasattr(__builtin__, "_"))

    22         dh(42)

    23         self.assertEqual(out.getvalue(), "42\n")

    24         self.assertEqual(__builtin__._, 42)

    25 

    26         del sys.stdout

    27         self.assertRaises(RuntimeError, dh, 42)

    28 

    29         sys.stdout = savestdout

    30 

    31     def test_lost_displayhook(self):

    32         olddisplayhook = sys.displayhook

    33         del sys.displayhook

    34         code = compile("42", "<string>", "single")

    35         self.assertRaises(RuntimeError, eval, code)

    36         sys.displayhook = olddisplayhook

    37 

    38     def test_custom_displayhook(self):

    39         olddisplayhook = sys.displayhook

    40         def baddisplayhook(obj):

    41             raise ValueError

    42         sys.displayhook = baddisplayhook

    43         code = compile("42", "<string>", "single")

    44         self.assertRaises(ValueError, eval, code)

    45         sys.displayhook = olddisplayhook

    46 

    47     def test_original_excepthook(self):

    48         savestderr = sys.stderr

    49         err = cStringIO.StringIO()

    50         sys.stderr = err

    51 

    52         eh = sys.__excepthook__

    53 

    54         self.assertRaises(TypeError, eh)

    55         try:

    56             raise ValueError(42)

    57         except ValueError, exc:

    58             eh(*sys.exc_info())

    59 

    60         sys.stderr = savestderr

    61         self.assert_(err.getvalue().endswith("ValueError: 42\n"))

    62 

    63     # FIXME: testing the code for a lost or replaced excepthook in

    64     # Python/pythonrun.c::PyErr_PrintEx() is tricky.

    65 

    66     def test_exc_clear(self):

    67         self.assertRaises(TypeError, sys.exc_clear, 42)

    68 

    69         # Verify that exc_info is present and matches exc, then clear it, and

    70         # check that it worked.

    71         def clear_check(exc):

    72             typ, value, traceback = sys.exc_info()

    73             self.assert_(typ is not None)

    74             self.assert_(value is exc)

    75             self.assert_(traceback is not None)

    76 

    77             sys.exc_clear()

    78 

    79             typ, value, traceback = sys.exc_info()

    80             self.assert_(typ is None)

    81             self.assert_(value is None)

    82             self.assert_(traceback is None)

    83 

    84         def clear():

    85             try:

    86                 raise ValueError, 42

    87             except ValueError, exc:

    88                 clear_check(exc)

    89 

    90         # Raise an exception and check that it can be cleared

    91         clear()

    92 

    93         # Verify that a frame currently handling an exception is

    94         # unaffected by calling exc_clear in a nested frame.

    95         try:

    96             raise ValueError, 13

    97         except ValueError, exc:

    98             typ1, value1, traceback1 = sys.exc_info()

    99             clear()

   100             typ2, value2, traceback2 = sys.exc_info()

   101 

   102             self.assert_(typ1 is typ2)

   103             self.assert_(value1 is exc)

   104             self.assert_(value1 is value2)

   105             self.assert_(traceback1 is traceback2)

   106 

   107         # Check that an exception can be cleared outside of an except block

   108         clear_check(exc)

   109 

   110     def test_exit(self):

   111         self.assertRaises(TypeError, sys.exit, 42, 42)

   112 

   113         # call without argument

   114         try:

   115             sys.exit(0)

   116         except SystemExit, exc:

   117             self.assertEquals(exc.code, 0)

   118         except:

   119             self.fail("wrong exception")

   120         else:

   121             self.fail("no exception")

   122 

   123         # call with tuple argument with one entry

   124         # entry will be unpacked

   125         try:

   126             sys.exit(42)

   127         except SystemExit, exc:

   128             self.assertEquals(exc.code, 42)

   129         except:

   130             self.fail("wrong exception")

   131         else:

   132             self.fail("no exception")

   133 

   134         # call with integer argument

   135         try:

   136             sys.exit((42,))

   137         except SystemExit, exc:

   138             self.assertEquals(exc.code, 42)

   139         except:

   140             self.fail("wrong exception")

   141         else:

   142             self.fail("no exception")

   143 

   144         # call with string argument

   145         try:

   146             sys.exit("exit")

   147         except SystemExit, exc:

   148             self.assertEquals(exc.code, "exit")

   149         except:

   150             self.fail("wrong exception")

   151         else:

   152             self.fail("no exception")

   153 

   154         # call with tuple argument with two entries

   155         try:

   156             sys.exit((17, 23))

   157         except SystemExit, exc:

   158             self.assertEquals(exc.code, (17, 23))

   159         except:

   160             self.fail("wrong exception")

   161         else:

   162             self.fail("no exception")

   163 

   164         # test that the exit machinery handles SystemExits properly

   165         import subprocess

   166         # both unnormalized...

   167         rc = subprocess.call([sys.executable, "-c",

   168                               "raise SystemExit, 46"])

   169         self.assertEqual(rc, 46)

   170         # ... and normalized

   171         rc = subprocess.call([sys.executable, "-c",

   172                               "raise SystemExit(47)"])

   173         self.assertEqual(rc, 47)

   174 

   175 

   176     def test_getdefaultencoding(self):

   177         if test.test_support.have_unicode:

   178             self.assertRaises(TypeError, sys.getdefaultencoding, 42)

   179             # can't check more than the type, as the user might have changed it

   180             self.assert_(isinstance(sys.getdefaultencoding(), str))

   181 

   182     # testing sys.settrace() is done in test_trace.py

   183     # testing sys.setprofile() is done in test_profile.py

   184 

   185     def test_setcheckinterval(self):

   186         self.assertRaises(TypeError, sys.setcheckinterval)

   187         orig = sys.getcheckinterval()

   188         for n in 0, 100, 120, orig: # orig last to restore starting state

   189             sys.setcheckinterval(n)

   190             self.assertEquals(sys.getcheckinterval(), n)

   191 

   192     def test_recursionlimit(self):

   193         self.assertRaises(TypeError, sys.getrecursionlimit, 42)

   194         oldlimit = sys.getrecursionlimit()

   195         self.assertRaises(TypeError, sys.setrecursionlimit)

   196         self.assertRaises(ValueError, sys.setrecursionlimit, -42)

   197         sys.setrecursionlimit(10000)

   198         self.assertEqual(sys.getrecursionlimit(), 10000)

   199         sys.setrecursionlimit(oldlimit)

   200 

   201     def test_getwindowsversion(self):

   202         if hasattr(sys, "getwindowsversion"):

   203             v = sys.getwindowsversion()

   204             self.assert_(isinstance(v, tuple))

   205             self.assertEqual(len(v), 5)

   206             self.assert_(isinstance(v[0], int))

   207             self.assert_(isinstance(v[1], int))

   208             self.assert_(isinstance(v[2], int))

   209             self.assert_(isinstance(v[3], int))

   210             self.assert_(isinstance(v[4], str))

   211 

   212     def test_dlopenflags(self):

   213         if hasattr(sys, "setdlopenflags"):

   214             self.assert_(hasattr(sys, "getdlopenflags"))

   215             self.assertRaises(TypeError, sys.getdlopenflags, 42)

   216             oldflags = sys.getdlopenflags()

   217             self.assertRaises(TypeError, sys.setdlopenflags)

   218             sys.setdlopenflags(oldflags+1)

   219             self.assertEqual(sys.getdlopenflags(), oldflags+1)

   220             sys.setdlopenflags(oldflags)

   221 

   222     def test_refcount(self):

   223         self.assertRaises(TypeError, sys.getrefcount)

   224         c = sys.getrefcount(None)

   225         n = None

   226         self.assertEqual(sys.getrefcount(None), c+1)

   227         del n

   228         self.assertEqual(sys.getrefcount(None), c)

   229         if hasattr(sys, "gettotalrefcount"):

   230             self.assert_(isinstance(sys.gettotalrefcount(), int))

   231 

   232     def test_getframe(self):

   233         self.assertRaises(TypeError, sys._getframe, 42, 42)

   234         self.assertRaises(ValueError, sys._getframe, 2000000000)

   235         self.assert_(

   236             SysModuleTest.test_getframe.im_func.func_code \

   237             is sys._getframe().f_code

   238         )

   239 

   240     # sys._current_frames() is a CPython-only gimmick.

   241     def test_current_frames(self):

   242         have_threads = True

   243         try:

   244             import thread

   245         except ImportError:

   246             have_threads = False

   247 

   248         if have_threads:

   249             self.current_frames_with_threads()

   250         else:

   251             self.current_frames_without_threads()

   252 

   253     # Test sys._current_frames() in a WITH_THREADS build.

   254     def current_frames_with_threads(self):

   255         import threading, thread

   256         import traceback

   257 

   258         # Spawn a thread that blocks at a known place.  Then the main

   259         # thread does sys._current_frames(), and verifies that the frames

   260         # returned make sense.

   261         entered_g = threading.Event()

   262         leave_g = threading.Event()

   263         thread_info = []  # the thread's id

   264 

   265         def f123():

   266             g456()

   267 

   268         def g456():

   269             thread_info.append(thread.get_ident())

   270             entered_g.set()

   271             leave_g.wait()

   272 

   273         t = threading.Thread(target=f123)

   274         t.start()

   275         entered_g.wait()

   276 

   277         # At this point, t has finished its entered_g.set(), although it's

   278         # impossible to guess whether it's still on that line or has moved on

   279         # to its leave_g.wait().

   280         self.assertEqual(len(thread_info), 1)

   281         thread_id = thread_info[0]

   282 

   283         d = sys._current_frames()

   284 

   285         main_id = thread.get_ident()

   286         self.assert_(main_id in d)

   287         self.assert_(thread_id in d)

   288 

   289         # Verify that the captured main-thread frame is _this_ frame.

   290         frame = d.pop(main_id)

   291         self.assert_(frame is sys._getframe())

   292 

   293         # Verify that the captured thread frame is blocked in g456, called

   294         # from f123.  This is a litte tricky, since various bits of

   295         # threading.py are also in the thread's call stack.

   296         frame = d.pop(thread_id)

   297         stack = traceback.extract_stack(frame)

   298         for i, (filename, lineno, funcname, sourceline) in enumerate(stack):

   299             if funcname == "f123":

   300                 break

   301         else:

   302             self.fail("didn't find f123() on thread's call stack")

   303 

   304         self.assertEqual(sourceline, "g456()")

   305 

   306         # And the next record must be for g456().

   307         filename, lineno, funcname, sourceline = stack[i+1]

   308         self.assertEqual(funcname, "g456")

   309         self.assert_(sourceline in ["leave_g.wait()", "entered_g.set()"])

   310 

   311         # Reap the spawned thread.

   312         leave_g.set()

   313         t.join()

   314 

   315     # Test sys._current_frames() when thread support doesn't exist.

   316     def current_frames_without_threads(self):

   317         # Not much happens here:  there is only one thread, with artificial

   318         # "thread id" 0.

   319         d = sys._current_frames()

   320         self.assertEqual(len(d), 1)

   321         self.assert_(0 in d)

   322         self.assert_(d[0] is sys._getframe())

   323 

   324     def test_attributes(self):

   325         self.assert_(isinstance(sys.api_version, int))

   326         self.assert_(isinstance(sys.argv, list))

   327         self.assert_(sys.byteorder in ("little", "big"))

   328         self.assert_(isinstance(sys.builtin_module_names, tuple))

   329         self.assert_(isinstance(sys.copyright, basestring))

   330         self.assert_(isinstance(sys.exec_prefix, basestring))

   331         self.assert_(isinstance(sys.executable, basestring))

   332         self.assert_(isinstance(sys.hexversion, int))

   333         self.assert_(isinstance(sys.maxint, int))

   334         if test.test_support.have_unicode:

   335             self.assert_(isinstance(sys.maxunicode, int))

   336         self.assert_(isinstance(sys.platform, basestring))

   337         self.assert_(isinstance(sys.prefix, basestring))

   338         self.assert_(isinstance(sys.version, basestring))

   339         vi = sys.version_info

   340         self.assert_(isinstance(vi, tuple))

   341         self.assertEqual(len(vi), 5)

   342         self.assert_(isinstance(vi[0], int))

   343         self.assert_(isinstance(vi[1], int))

   344         self.assert_(isinstance(vi[2], int))

   345         self.assert_(vi[3] in ("alpha", "beta", "candidate", "final"))

   346         self.assert_(isinstance(vi[4], int))

   347 

   348     def test_43581(self):

   349         # Can't use sys.stdout, as this is a cStringIO object when

   350         # the test runs under regrtest.

   351         self.assert_(sys.__stdout__.encoding == sys.__stderr__.encoding)

   352 

   353 def test_main():

   354     test.test_support.run_unittest(SysModuleTest)

   355 

   356 if __name__ == "__main__":

   357     test_main()