← Back to branch summary

~jfb-tempo-consulting/unifield-wm/sync-env-py3

« back to all changes in this revision

Viewing changes to unittest27/test/test_break.py

  • Committer: Samus CTO
  • Date: 2012-09-05 10:40:27 UTC
  • Revision ID: cto@openerp.com-20120905104027-geoynct7122bnoig
[IMPORT] imported unittest from Python 2.7

Show diffs side-by-side

added added

removed removed

Lines of Context:
unittest27/test/test_break.py
 
1
import gc
 
2
import os
 
3
import sys
 
4
import signal
 
5
import weakref
 
6
 
 
7
from cStringIO import StringIO
 
8
 
 
9
 
 
10
import unittest
 
11
 
 
12
 
 
13
@unittest.skipUnless(hasattr(os, 'kill'), "Test requires os.kill")
 
14
@unittest.skipIf(sys.platform =="win32", "Test cannot run on Windows")
 
15
@unittest.skipIf(sys.platform == 'freebsd6', "Test kills regrtest on freebsd6 "
 
16
    "if threads have been used")
 
17
class TestBreak(unittest.TestCase):
 
18
 
 
19
    def setUp(self):
 
20
        self._default_handler = signal.getsignal(signal.SIGINT)
 
21
 
 
22
    def tearDown(self):
 
23
        signal.signal(signal.SIGINT, self._default_handler)
 
24
        unittest.signals._results = weakref.WeakKeyDictionary()
 
25
        unittest.signals._interrupt_handler = None
 
26
 
 
27
 
 
28
    def testInstallHandler(self):
 
29
        default_handler = signal.getsignal(signal.SIGINT)
 
30
        unittest.installHandler()
 
31
        self.assertNotEqual(signal.getsignal(signal.SIGINT), default_handler)
 
32
 
 
33
        try:
 
34
            pid = os.getpid()
 
35
            os.kill(pid, signal.SIGINT)
 
36
        except KeyboardInterrupt:
 
37
            self.fail("KeyboardInterrupt not handled")
 
38
 
 
39
        self.assertTrue(unittest.signals._interrupt_handler.called)
 
40
 
 
41
    def testRegisterResult(self):
 
42
        result = unittest.TestResult()
 
43
        unittest.registerResult(result)
 
44
 
 
45
        for ref in unittest.signals._results:
 
46
            if ref is result:
 
47
                break
 
48
            elif ref is not result:
 
49
                self.fail("odd object in result set")
 
50
        else:
 
51
            self.fail("result not found")
 
52
 
 
53
 
 
54
    def testInterruptCaught(self):
 
55
        default_handler = signal.getsignal(signal.SIGINT)
 
56
 
 
57
        result = unittest.TestResult()
 
58
        unittest.installHandler()
 
59
        unittest.registerResult(result)
 
60
 
 
61
        self.assertNotEqual(signal.getsignal(signal.SIGINT), default_handler)
 
62
 
 
63
        def test(result):
 
64
            pid = os.getpid()
 
65
            os.kill(pid, signal.SIGINT)
 
66
            result.breakCaught = True
 
67
            self.assertTrue(result.shouldStop)
 
68
 
 
69
        try:
 
70
            test(result)
 
71
        except KeyboardInterrupt:
 
72
            self.fail("KeyboardInterrupt not handled")
 
73
        self.assertTrue(result.breakCaught)
 
74
 
 
75
 
 
76
    def testSecondInterrupt(self):
 
77
        result = unittest.TestResult()
 
78
        unittest.installHandler()
 
79
        unittest.registerResult(result)
 
80
 
 
81
        def test(result):
 
82
            pid = os.getpid()
 
83
            os.kill(pid, signal.SIGINT)
 
84
            result.breakCaught = True
 
85
            self.assertTrue(result.shouldStop)
 
86
            os.kill(pid, signal.SIGINT)
 
87
            self.fail("Second KeyboardInterrupt not raised")
 
88
 
 
89
        try:
 
90
            test(result)
 
91
        except KeyboardInterrupt:
 
92
            pass
 
93
        else:
 
94
            self.fail("Second KeyboardInterrupt not raised")
 
95
        self.assertTrue(result.breakCaught)
 
96
 
 
97
 
 
98
    def testTwoResults(self):
 
99
        unittest.installHandler()
 
100
 
 
101
        result = unittest.TestResult()
 
102
        unittest.registerResult(result)
 
103
        new_handler = signal.getsignal(signal.SIGINT)
 
104
 
 
105
        result2 = unittest.TestResult()
 
106
        unittest.registerResult(result2)
 
107
        self.assertEqual(signal.getsignal(signal.SIGINT), new_handler)
 
108
 
 
109
        result3 = unittest.TestResult()
 
110
 
 
111
        def test(result):
 
112
            pid = os.getpid()
 
113
            os.kill(pid, signal.SIGINT)
 
114
 
 
115
        try:
 
116
            test(result)
 
117
        except KeyboardInterrupt:
 
118
            self.fail("KeyboardInterrupt not handled")
 
119
 
 
120
        self.assertTrue(result.shouldStop)
 
121
        self.assertTrue(result2.shouldStop)
 
122
        self.assertFalse(result3.shouldStop)
 
123
 
 
124
 
 
125
    def testHandlerReplacedButCalled(self):
 
126
        # If our handler has been replaced (is no longer installed) but is
 
127
        # called by the *new* handler, then it isn't safe to delay the
 
128
        # SIGINT and we should immediately delegate to the default handler
 
129
        unittest.installHandler()
 
130
 
 
131
        handler = signal.getsignal(signal.SIGINT)
 
132
        def new_handler(frame, signum):
 
133
            handler(frame, signum)
 
134
        signal.signal(signal.SIGINT, new_handler)
 
135
 
 
136
        try:
 
137
            pid = os.getpid()
 
138
            os.kill(pid, signal.SIGINT)
 
139
        except KeyboardInterrupt:
 
140
            pass
 
141
        else:
 
142
            self.fail("replaced but delegated handler doesn't raise interrupt")
 
143
 
 
144
    def testRunner(self):
 
145
        # Creating a TextTestRunner with the appropriate argument should
 
146
        # register the TextTestResult it creates
 
147
        runner = unittest.TextTestRunner(stream=StringIO())
 
148
 
 
149
        result = runner.run(unittest.TestSuite())
 
150
        self.assertIn(result, unittest.signals._results)
 
151
 
 
152
    def testWeakReferences(self):
 
153
        # Calling registerResult on a result should not keep it alive
 
154
        result = unittest.TestResult()
 
155
        unittest.registerResult(result)
 
156
 
 
157
        ref = weakref.ref(result)
 
158
        del result
 
159
 
 
160
        # For non-reference counting implementations
 
161
        gc.collect();gc.collect()
 
162
        self.assertIsNone(ref())
 
163
 
 
164
 
 
165
    def testRemoveResult(self):
 
166
        result = unittest.TestResult()
 
167
        unittest.registerResult(result)
 
168
 
 
169
        unittest.installHandler()
 
170
        self.assertTrue(unittest.removeResult(result))
 
171
 
 
172
        # Should this raise an error instead?
 
173
        self.assertFalse(unittest.removeResult(unittest.TestResult()))
 
174
 
 
175
        try:
 
176
            pid = os.getpid()
 
177
            os.kill(pid, signal.SIGINT)
 
178
        except KeyboardInterrupt:
 
179
            pass
 
180
 
 
181
        self.assertFalse(result.shouldStop)
 
182
 
 
183
    def testMainInstallsHandler(self):
 
184
        failfast = object()
 
185
        test = object()
 
186
        verbosity = object()
 
187
        result = object()
 
188
        default_handler = signal.getsignal(signal.SIGINT)
 
189
 
 
190
        class FakeRunner(object):
 
191
            initArgs = []
 
192
            runArgs = []
 
193
            def __init__(self, *args, **kwargs):
 
194
                self.initArgs.append((args, kwargs))
 
195
            def run(self, test):
 
196
                self.runArgs.append(test)
 
197
                return result
 
198
 
 
199
        class Program(unittest.TestProgram):
 
200
            def __init__(self, catchbreak):
 
201
                self.exit = False
 
202
                self.verbosity = verbosity
 
203
                self.failfast = failfast
 
204
                self.catchbreak = catchbreak
 
205
                self.testRunner = FakeRunner
 
206
                self.test = test
 
207
                self.result = None
 
208
 
 
209
        p = Program(False)
 
210
        p.runTests()
 
211
 
 
212
        self.assertEqual(FakeRunner.initArgs, [((), {'buffer': None,
 
213
                                                     'verbosity': verbosity,
 
214
                                                     'failfast': failfast})])
 
215
        self.assertEqual(FakeRunner.runArgs, [test])
 
216
        self.assertEqual(p.result, result)
 
217
 
 
218
        self.assertEqual(signal.getsignal(signal.SIGINT), default_handler)
 
219
 
 
220
        FakeRunner.initArgs = []
 
221
        FakeRunner.runArgs = []
 
222
        p = Program(True)
 
223
        p.runTests()
 
224
 
 
225
        self.assertEqual(FakeRunner.initArgs, [((), {'buffer': None,
 
226
                                                     'verbosity': verbosity,
 
227
                                                     'failfast': failfast})])
 
228
        self.assertEqual(FakeRunner.runArgs, [test])
 
229
        self.assertEqual(p.result, result)
 
230
 
 
231
        self.assertNotEqual(signal.getsignal(signal.SIGINT), default_handler)
 
232
 
 
233
    def testRemoveHandler(self):
 
234
        default_handler = signal.getsignal(signal.SIGINT)
 
235
        unittest.installHandler()
 
236
        unittest.removeHandler()
 
237
        self.assertEqual(signal.getsignal(signal.SIGINT), default_handler)
 
238
 
 
239
        # check that calling removeHandler multiple times has no ill-effect
 
240
        unittest.removeHandler()
 
241
        self.assertEqual(signal.getsignal(signal.SIGINT), default_handler)
 
242
 
 
243
    def testRemoveHandlerAsDecorator(self):
 
244
        default_handler = signal.getsignal(signal.SIGINT)
 
245
        unittest.installHandler()
 
246
 
 
247
        @unittest.removeHandler
 
248
        def test():
 
249
            self.assertEqual(signal.getsignal(signal.SIGINT), default_handler)
 
250
 
 
251
        test()
 
252
        self.assertNotEqual(signal.getsignal(signal.SIGINT), default_handler)