← Back to branch summary

~ubuntu-branches/ubuntu/karmic/pypy/karmic

« back to all changes in this revision

Viewing changes to lib-python/modified-2.4.1/test/test_sys.py

  • Committer: Bazaar Package Importer
  • Author(s): Alexandre Fayolle
  • Date: 2007-04-13 09:33:09 UTC
  • Revision ID: james.westby@ubuntu.com-20070413093309-yoojh4jcoocu2krz
Tags: upstream-1.0.0
Import upstream version 1.0.0

Show diffs side-by-side

added added

removed removed

Lines of Context:
lib-python/modified-2.4.1/test/test_sys.py
 
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
    def test_getdefaultencoding(self):
 
165
        if test.test_support.have_unicode:
 
166
            self.assertRaises(TypeError, sys.getdefaultencoding, 42)
 
167
            # can't check more than the type, as the user might have changed it
 
168
            self.assert_(isinstance(sys.getdefaultencoding(), str))
 
169
 
 
170
    # testing sys.settrace() is done in test_trace.py
 
171
    # testing sys.setprofile() is done in test_profile.py
 
172
 
 
173
    def test_setcheckinterval(self):
 
174
        self.assertRaises(TypeError, sys.setcheckinterval)
 
175
        orig = sys.getcheckinterval()
 
176
        for n in 0, 100, 120, orig: # orig last to restore starting state
 
177
            sys.setcheckinterval(n)
 
178
            self.assertEquals(sys.getcheckinterval(), n)
 
179
 
 
180
    def test_recursionlimit(self):
 
181
        self.assertRaises(TypeError, sys.getrecursionlimit, 42)
 
182
        oldlimit = sys.getrecursionlimit()
 
183
        self.assertRaises(TypeError, sys.setrecursionlimit)
 
184
        self.assertRaises(ValueError, sys.setrecursionlimit, -42)
 
185
        sys.setrecursionlimit(10000)
 
186
        self.assertEqual(sys.getrecursionlimit(), 10000)
 
187
        sys.setrecursionlimit(oldlimit)
 
188
 
 
189
    def test_getwindowsversion(self):
 
190
        if hasattr(sys, "getwindowsversion"):
 
191
            v = sys.getwindowsversion()
 
192
            self.assert_(isinstance(v, tuple))
 
193
            self.assertEqual(len(v), 5)
 
194
            self.assert_(isinstance(v[0], int))
 
195
            self.assert_(isinstance(v[1], int))
 
196
            self.assert_(isinstance(v[2], int))
 
197
            self.assert_(isinstance(v[3], int))
 
198
            self.assert_(isinstance(v[4], str))
 
199
 
 
200
    def test_dlopenflags(self):
 
201
        if hasattr(sys, "setdlopenflags"):
 
202
            self.assert_(hasattr(sys, "getdlopenflags"))
 
203
            self.assertRaises(TypeError, sys.getdlopenflags, 42)
 
204
            oldflags = sys.getdlopenflags()
 
205
            self.assertRaises(TypeError, sys.setdlopenflags)
 
206
            sys.setdlopenflags(oldflags+1)
 
207
            self.assertEqual(sys.getdlopenflags(), oldflags+1)
 
208
            sys.setdlopenflags(oldflags)
 
209
 
 
210
    def DONT_test_refcount(self):
 
211
        self.assertRaises(TypeError, sys.getrefcount)
 
212
        c = sys.getrefcount(None)
 
213
        n = None
 
214
        self.assertEqual(sys.getrefcount(None), c+1)
 
215
        del n
 
216
        self.assertEqual(sys.getrefcount(None), c)
 
217
        if hasattr(sys, "gettotalrefcount"):
 
218
            self.assert_(isinstance(sys.gettotalrefcount(), int))
 
219
 
 
220
    def test_getframe(self):
 
221
        self.assertRaises(TypeError, sys._getframe, 42, 42)
 
222
        self.assertRaises(ValueError, sys._getframe, 2000000000)
 
223
        self.assert_(
 
224
            SysModuleTest.test_getframe.im_func.func_code \
 
225
            is sys._getframe().f_code
 
226
        )
 
227
 
 
228
    def test_attributes(self):
 
229
        self.assert_(isinstance(sys.api_version, int))
 
230
        self.assert_(isinstance(sys.argv, list))
 
231
        self.assert_(sys.byteorder in ("little", "big"))
 
232
        self.assert_(isinstance(sys.builtin_module_names, tuple))
 
233
        self.assert_(isinstance(sys.copyright, basestring))
 
234
        self.assert_(isinstance(sys.exec_prefix, basestring))
 
235
        self.assert_(isinstance(sys.executable, basestring))
 
236
        self.assert_(isinstance(sys.hexversion, int))
 
237
        self.assert_(isinstance(sys.maxint, int))
 
238
        self.assert_(isinstance(sys.maxunicode, int))
 
239
        self.assert_(isinstance(sys.platform, basestring))
 
240
        self.assert_(isinstance(sys.prefix, basestring))
 
241
        self.assert_(isinstance(sys.version, basestring))
 
242
        vi = sys.version_info
 
243
        self.assert_(isinstance(vi, tuple))
 
244
        self.assertEqual(len(vi), 5)
 
245
        self.assert_(isinstance(vi[0], int))
 
246
        self.assert_(isinstance(vi[1], int))
 
247
        self.assert_(isinstance(vi[2], int))
 
248
        self.assert_(vi[3] in ("alpha", "beta", "candidate", "final"))
 
249
        self.assert_(isinstance(vi[4], int))
 
250
 
 
251
def test_main():
 
252
    test.test_support.run_unittest(SysModuleTest)
 
253
 
 
254
if __name__ == "__main__":
 
255
    test_main()