test_sys.py revision f0db38dbf89c642bb43acb193c41e0329461be33 
1# -*- coding: iso-8859-1 -*-
2import unittest, test.test_support
3import sys, cStringIO
4
5class 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    def test_attributes(self):
241        self.assert_(isinstance(sys.api_version, int))
242        self.assert_(isinstance(sys.argv, list))
243        self.assert_(sys.byteorder in ("little", "big"))
244        self.assert_(isinstance(sys.builtin_module_names, tuple))
245        self.assert_(isinstance(sys.copyright, basestring))
246        self.assert_(isinstance(sys.exec_prefix, basestring))
247        self.assert_(isinstance(sys.executable, basestring))
248        self.assert_(isinstance(sys.hexversion, int))
249        self.assert_(isinstance(sys.maxint, int))
250        self.assert_(isinstance(sys.maxunicode, int))
251        self.assert_(isinstance(sys.platform, basestring))
252        self.assert_(isinstance(sys.prefix, basestring))
253        self.assert_(isinstance(sys.version, basestring))
254        vi = sys.version_info
255        self.assert_(isinstance(vi, tuple))
256        self.assertEqual(len(vi), 5)
257        self.assert_(isinstance(vi[0], int))
258        self.assert_(isinstance(vi[1], int))
259        self.assert_(isinstance(vi[2], int))
260        self.assert_(vi[3] in ("alpha", "beta", "candidate", "final"))
261        self.assert_(isinstance(vi[4], int))
262
263def test_main():
264    test.test_support.run_unittest(SysModuleTest)
265
266if __name__ == "__main__":
267    test_main()
268