python (3.12.0)
1 import contextlib
2 import difflib
3 import pprint
4 import pickle
5 import re
6 import sys
7 import logging
8 import warnings
9 import weakref
10 import inspect
11 import types
12
13 from copy import deepcopy
14 from test import support
15
16 import unittest
17
18 from test.test_unittest.support import (
19 TestEquality, TestHashing, LoggingResult, LegacyLoggingResult,
20 ResultWithNoStartTestRunStopTestRun
21 )
22 from test.support import captured_stderr, gc_collect
23
24
25 log_foo = logging.getLogger('foo')
26 log_foobar = logging.getLogger('foo.bar')
27 log_quux = logging.getLogger('quux')
28
29
30 class ESC[4;38;5;81mTest(ESC[4;38;5;149mobject):
31 "Keep these TestCase classes out of the main namespace"
32
33 class ESC[4;38;5;81mFoo(ESC[4;38;5;149munittestESC[4;38;5;149m.ESC[4;38;5;149mTestCase):
34 def runTest(self): pass
35 def test1(self): pass
36
37 class ESC[4;38;5;81mBar(ESC[4;38;5;149mFoo):
38 def test2(self): pass
39
40 class ESC[4;38;5;81mLoggingTestCase(ESC[4;38;5;149munittestESC[4;38;5;149m.ESC[4;38;5;149mTestCase):
41 """A test case which logs its calls."""
42
43 def __init__(self, events):
44 super(Test.LoggingTestCase, self).__init__('test')
45 self.events = events
46
47 def setUp(self):
48 self.events.append('setUp')
49
50 def test(self):
51 self.events.append('test')
52
53 def tearDown(self):
54 self.events.append('tearDown')
55
56
57 class ESC[4;38;5;81mTest_TestCase(ESC[4;38;5;149munittestESC[4;38;5;149m.ESC[4;38;5;149mTestCase, ESC[4;38;5;149mTestEquality, ESC[4;38;5;149mTestHashing):
58
59 ### Set up attributes used by inherited tests
60 ################################################################
61
62 # Used by TestHashing.test_hash and TestEquality.test_eq
63 eq_pairs = [(Test.Foo('test1'), Test.Foo('test1'))]
64
65 # Used by TestEquality.test_ne
66 ne_pairs = [(Test.Foo('test1'), Test.Foo('runTest')),
67 (Test.Foo('test1'), Test.Bar('test1')),
68 (Test.Foo('test1'), Test.Bar('test2'))]
69
70 ################################################################
71 ### /Set up attributes used by inherited tests
72
73
74 # "class TestCase([methodName])"
75 # ...
76 # "Each instance of TestCase will run a single test method: the
77 # method named methodName."
78 # ...
79 # "methodName defaults to "runTest"."
80 #
81 # Make sure it really is optional, and that it defaults to the proper
82 # thing.
83 def test_init__no_test_name(self):
84 class ESC[4;38;5;81mTest(ESC[4;38;5;149munittestESC[4;38;5;149m.ESC[4;38;5;149mTestCase):
85 def runTest(self): raise MyException()
86 def test(self): pass
87
88 self.assertEqual(Test().id()[-13:], '.Test.runTest')
89
90 # test that TestCase can be instantiated with no args
91 # primarily for use at the interactive interpreter
92 test = unittest.TestCase()
93 test.assertEqual(3, 3)
94 with test.assertRaises(test.failureException):
95 test.assertEqual(3, 2)
96
97 with self.assertRaises(AttributeError):
98 test.run()
99
100 # "class TestCase([methodName])"
101 # ...
102 # "Each instance of TestCase will run a single test method: the
103 # method named methodName."
104 def test_init__test_name__valid(self):
105 class ESC[4;38;5;81mTest(ESC[4;38;5;149munittestESC[4;38;5;149m.ESC[4;38;5;149mTestCase):
106 def runTest(self): raise MyException()
107 def test(self): pass
108
109 self.assertEqual(Test('test').id()[-10:], '.Test.test')
110
111 # "class TestCase([methodName])"
112 # ...
113 # "Each instance of TestCase will run a single test method: the
114 # method named methodName."
115 def test_init__test_name__invalid(self):
116 class ESC[4;38;5;81mTest(ESC[4;38;5;149munittestESC[4;38;5;149m.ESC[4;38;5;149mTestCase):
117 def runTest(self): raise MyException()
118 def test(self): pass
119
120 try:
121 Test('testfoo')
122 except ValueError:
123 pass
124 else:
125 self.fail("Failed to raise ValueError")
126
127 # "Return the number of tests represented by the this test object. For
128 # TestCase instances, this will always be 1"
129 def test_countTestCases(self):
130 class ESC[4;38;5;81mFoo(ESC[4;38;5;149munittestESC[4;38;5;149m.ESC[4;38;5;149mTestCase):
131 def test(self): pass
132
133 self.assertEqual(Foo('test').countTestCases(), 1)
134
135 # "Return the default type of test result object to be used to run this
136 # test. For TestCase instances, this will always be
137 # unittest.TestResult; subclasses of TestCase should
138 # override this as necessary."
139 def test_defaultTestResult(self):
140 class ESC[4;38;5;81mFoo(ESC[4;38;5;149munittestESC[4;38;5;149m.ESC[4;38;5;149mTestCase):
141 def runTest(self):
142 pass
143
144 result = Foo().defaultTestResult()
145 self.assertEqual(type(result), unittest.TestResult)
146
147 # "When a setUp() method is defined, the test runner will run that method
148 # prior to each test. Likewise, if a tearDown() method is defined, the
149 # test runner will invoke that method after each test. In the example,
150 # setUp() was used to create a fresh sequence for each test."
151 #
152 # Make sure the proper call order is maintained, even if setUp() raises
153 # an exception.
154 def test_run_call_order__error_in_setUp(self):
155 events = []
156 result = LoggingResult(events)
157
158 class ESC[4;38;5;81mFoo(ESC[4;38;5;149mTestESC[4;38;5;149m.ESC[4;38;5;149mLoggingTestCase):
159 def setUp(self):
160 super(Foo, self).setUp()
161 raise RuntimeError('raised by Foo.setUp')
162
163 Foo(events).run(result)
164 expected = ['startTest', 'setUp', 'addError', 'stopTest']
165 self.assertEqual(events, expected)
166
167 # "With a temporary result stopTestRun is called when setUp errors.
168 def test_run_call_order__error_in_setUp_default_result(self):
169 events = []
170
171 class ESC[4;38;5;81mFoo(ESC[4;38;5;149mTestESC[4;38;5;149m.ESC[4;38;5;149mLoggingTestCase):
172 def defaultTestResult(self):
173 return LoggingResult(self.events)
174
175 def setUp(self):
176 super(Foo, self).setUp()
177 raise RuntimeError('raised by Foo.setUp')
178
179 Foo(events).run()
180 expected = ['startTestRun', 'startTest', 'setUp', 'addError',
181 'stopTest', 'stopTestRun']
182 self.assertEqual(events, expected)
183
184 # "When a setUp() method is defined, the test runner will run that method
185 # prior to each test. Likewise, if a tearDown() method is defined, the
186 # test runner will invoke that method after each test. In the example,
187 # setUp() was used to create a fresh sequence for each test."
188 #
189 # Make sure the proper call order is maintained, even if the test raises
190 # an error (as opposed to a failure).
191 def test_run_call_order__error_in_test(self):
192 events = []
193 result = LoggingResult(events)
194
195 class ESC[4;38;5;81mFoo(ESC[4;38;5;149mTestESC[4;38;5;149m.ESC[4;38;5;149mLoggingTestCase):
196 def test(self):
197 super(Foo, self).test()
198 raise RuntimeError('raised by Foo.test')
199
200 expected = ['startTest', 'setUp', 'test',
201 'addError', 'tearDown', 'stopTest']
202 Foo(events).run(result)
203 self.assertEqual(events, expected)
204
205 # "With a default result, an error in the test still results in stopTestRun
206 # being called."
207 def test_run_call_order__error_in_test_default_result(self):
208 events = []
209
210 class ESC[4;38;5;81mFoo(ESC[4;38;5;149mTestESC[4;38;5;149m.ESC[4;38;5;149mLoggingTestCase):
211 def defaultTestResult(self):
212 return LoggingResult(self.events)
213
214 def test(self):
215 super(Foo, self).test()
216 raise RuntimeError('raised by Foo.test')
217
218 expected = ['startTestRun', 'startTest', 'setUp', 'test',
219 'addError', 'tearDown', 'stopTest', 'stopTestRun']
220 Foo(events).run()
221 self.assertEqual(events, expected)
222
223 # "When a setUp() method is defined, the test runner will run that method
224 # prior to each test. Likewise, if a tearDown() method is defined, the
225 # test runner will invoke that method after each test. In the example,
226 # setUp() was used to create a fresh sequence for each test."
227 #
228 # Make sure the proper call order is maintained, even if the test signals
229 # a failure (as opposed to an error).
230 def test_run_call_order__failure_in_test(self):
231 events = []
232 result = LoggingResult(events)
233
234 class ESC[4;38;5;81mFoo(ESC[4;38;5;149mTestESC[4;38;5;149m.ESC[4;38;5;149mLoggingTestCase):
235 def test(self):
236 super(Foo, self).test()
237 self.fail('raised by Foo.test')
238
239 expected = ['startTest', 'setUp', 'test',
240 'addFailure', 'tearDown', 'stopTest']
241 Foo(events).run(result)
242 self.assertEqual(events, expected)
243
244 # "When a test fails with a default result stopTestRun is still called."
245 def test_run_call_order__failure_in_test_default_result(self):
246
247 class ESC[4;38;5;81mFoo(ESC[4;38;5;149mTestESC[4;38;5;149m.ESC[4;38;5;149mLoggingTestCase):
248 def defaultTestResult(self):
249 return LoggingResult(self.events)
250 def test(self):
251 super(Foo, self).test()
252 self.fail('raised by Foo.test')
253
254 expected = ['startTestRun', 'startTest', 'setUp', 'test',
255 'addFailure', 'tearDown', 'stopTest', 'stopTestRun']
256 events = []
257 Foo(events).run()
258 self.assertEqual(events, expected)
259
260 # "When a setUp() method is defined, the test runner will run that method
261 # prior to each test. Likewise, if a tearDown() method is defined, the
262 # test runner will invoke that method after each test. In the example,
263 # setUp() was used to create a fresh sequence for each test."
264 #
265 # Make sure the proper call order is maintained, even if tearDown() raises
266 # an exception.
267 def test_run_call_order__error_in_tearDown(self):
268 events = []
269 result = LoggingResult(events)
270
271 class ESC[4;38;5;81mFoo(ESC[4;38;5;149mTestESC[4;38;5;149m.ESC[4;38;5;149mLoggingTestCase):
272 def tearDown(self):
273 super(Foo, self).tearDown()
274 raise RuntimeError('raised by Foo.tearDown')
275
276 Foo(events).run(result)
277 expected = ['startTest', 'setUp', 'test', 'tearDown', 'addError',
278 'stopTest']
279 self.assertEqual(events, expected)
280
281 # "When tearDown errors with a default result stopTestRun is still called."
282 def test_run_call_order__error_in_tearDown_default_result(self):
283
284 class ESC[4;38;5;81mFoo(ESC[4;38;5;149mTestESC[4;38;5;149m.ESC[4;38;5;149mLoggingTestCase):
285 def defaultTestResult(self):
286 return LoggingResult(self.events)
287 def tearDown(self):
288 super(Foo, self).tearDown()
289 raise RuntimeError('raised by Foo.tearDown')
290
291 events = []
292 Foo(events).run()
293 expected = ['startTestRun', 'startTest', 'setUp', 'test', 'tearDown',
294 'addError', 'stopTest', 'stopTestRun']
295 self.assertEqual(events, expected)
296
297 # "TestCase.run() still works when the defaultTestResult is a TestResult
298 # that does not support startTestRun and stopTestRun.
299 def test_run_call_order_default_result(self):
300
301 class ESC[4;38;5;81mFoo(ESC[4;38;5;149munittestESC[4;38;5;149m.ESC[4;38;5;149mTestCase):
302 def defaultTestResult(self):
303 return ResultWithNoStartTestRunStopTestRun()
304 def test(self):
305 pass
306
307 with self.assertWarns(RuntimeWarning):
308 Foo('test').run()
309
310 def test_deprecation_of_return_val_from_test(self):
311 # Issue 41322 - deprecate return of value that is not None from a test
312 class ESC[4;38;5;81mNothing:
313 def __eq__(self, o):
314 return o is None
315 class ESC[4;38;5;81mFoo(ESC[4;38;5;149munittestESC[4;38;5;149m.ESC[4;38;5;149mTestCase):
316 def test1(self):
317 return 1
318 def test2(self):
319 yield 1
320 def test3(self):
321 return Nothing()
322
323 with self.assertWarns(DeprecationWarning) as w:
324 Foo('test1').run()
325 self.assertIn('It is deprecated to return a value that is not None', str(w.warning))
326 self.assertIn('test1', str(w.warning))
327 self.assertEqual(w.filename, __file__)
328
329 with self.assertWarns(DeprecationWarning) as w:
330 Foo('test2').run()
331 self.assertIn('It is deprecated to return a value that is not None', str(w.warning))
332 self.assertIn('test2', str(w.warning))
333 self.assertEqual(w.filename, __file__)
334
335 with self.assertWarns(DeprecationWarning) as w:
336 Foo('test3').run()
337 self.assertIn('It is deprecated to return a value that is not None', str(w.warning))
338 self.assertIn('test3', str(w.warning))
339 self.assertEqual(w.filename, __file__)
340
341 def _check_call_order__subtests(self, result, events, expected_events):
342 class ESC[4;38;5;81mFoo(ESC[4;38;5;149mTestESC[4;38;5;149m.ESC[4;38;5;149mLoggingTestCase):
343 def test(self):
344 super(Foo, self).test()
345 for i in [1, 2, 3]:
346 with self.subTest(i=i):
347 if i == 1:
348 self.fail('failure')
349 for j in [2, 3]:
350 with self.subTest(j=j):
351 if i * j == 6:
352 raise RuntimeError('raised by Foo.test')
353 1 / 0
354
355 # Order is the following:
356 # i=1 => subtest failure
357 # i=2, j=2 => subtest success
358 # i=2, j=3 => subtest error
359 # i=3, j=2 => subtest error
360 # i=3, j=3 => subtest success
361 # toplevel => error
362 Foo(events).run(result)
363 self.assertEqual(events, expected_events)
364
365 def test_run_call_order__subtests(self):
366 events = []
367 result = LoggingResult(events)
368 expected = ['startTest', 'setUp', 'test',
369 'addSubTestFailure', 'addSubTestSuccess',
370 'addSubTestFailure', 'addSubTestFailure',
371 'addSubTestSuccess', 'addError', 'tearDown', 'stopTest']
372 self._check_call_order__subtests(result, events, expected)
373
374 def test_run_call_order__subtests_legacy(self):
375 # With a legacy result object (without an addSubTest method),
376 # text execution stops after the first subtest failure.
377 events = []
378 result = LegacyLoggingResult(events)
379 expected = ['startTest', 'setUp', 'test',
380 'addFailure', 'tearDown', 'stopTest']
381 self._check_call_order__subtests(result, events, expected)
382
383 def _check_call_order__subtests_success(self, result, events, expected_events):
384 class ESC[4;38;5;81mFoo(ESC[4;38;5;149mTestESC[4;38;5;149m.ESC[4;38;5;149mLoggingTestCase):
385 def test(self):
386 super(Foo, self).test()
387 for i in [1, 2]:
388 with self.subTest(i=i):
389 for j in [2, 3]:
390 with self.subTest(j=j):
391 pass
392
393 Foo(events).run(result)
394 self.assertEqual(events, expected_events)
395
396 def test_run_call_order__subtests_success(self):
397 events = []
398 result = LoggingResult(events)
399 # The 6 subtest successes are individually recorded, in addition
400 # to the whole test success.
401 expected = (['startTest', 'setUp', 'test']
402 + 6 * ['addSubTestSuccess']
403 + ['tearDown', 'addSuccess', 'stopTest'])
404 self._check_call_order__subtests_success(result, events, expected)
405
406 def test_run_call_order__subtests_success_legacy(self):
407 # With a legacy result, only the whole test success is recorded.
408 events = []
409 result = LegacyLoggingResult(events)
410 expected = ['startTest', 'setUp', 'test', 'tearDown',
411 'addSuccess', 'stopTest']
412 self._check_call_order__subtests_success(result, events, expected)
413
414 def test_run_call_order__subtests_failfast(self):
415 events = []
416 result = LoggingResult(events)
417 result.failfast = True
418
419 class ESC[4;38;5;81mFoo(ESC[4;38;5;149mTestESC[4;38;5;149m.ESC[4;38;5;149mLoggingTestCase):
420 def test(self):
421 super(Foo, self).test()
422 with self.subTest(i=1):
423 self.fail('failure')
424 with self.subTest(i=2):
425 self.fail('failure')
426 self.fail('failure')
427
428 expected = ['startTest', 'setUp', 'test',
429 'addSubTestFailure', 'tearDown', 'stopTest']
430 Foo(events).run(result)
431 self.assertEqual(events, expected)
432
433 def test_subtests_failfast(self):
434 # Ensure proper test flow with subtests and failfast (issue #22894)
435 events = []
436
437 class ESC[4;38;5;81mFoo(ESC[4;38;5;149munittestESC[4;38;5;149m.ESC[4;38;5;149mTestCase):
438 def test_a(self):
439 with self.subTest():
440 events.append('a1')
441 events.append('a2')
442
443 def test_b(self):
444 with self.subTest():
445 events.append('b1')
446 with self.subTest():
447 self.fail('failure')
448 events.append('b2')
449
450 def test_c(self):
451 events.append('c')
452
453 result = unittest.TestResult()
454 result.failfast = True
455 suite = unittest.TestLoader().loadTestsFromTestCase(Foo)
456 suite.run(result)
457
458 expected = ['a1', 'a2', 'b1']
459 self.assertEqual(events, expected)
460
461 def test_subtests_debug(self):
462 # Test debug() with a test that uses subTest() (bpo-34900)
463 events = []
464
465 class ESC[4;38;5;81mFoo(ESC[4;38;5;149munittestESC[4;38;5;149m.ESC[4;38;5;149mTestCase):
466 def test_a(self):
467 events.append('test case')
468 with self.subTest():
469 events.append('subtest 1')
470
471 Foo('test_a').debug()
472
473 self.assertEqual(events, ['test case', 'subtest 1'])
474
475 # "This class attribute gives the exception raised by the test() method.
476 # If a test framework needs to use a specialized exception, possibly to
477 # carry additional information, it must subclass this exception in
478 # order to ``play fair'' with the framework. The initial value of this
479 # attribute is AssertionError"
480 def test_failureException__default(self):
481 class ESC[4;38;5;81mFoo(ESC[4;38;5;149munittestESC[4;38;5;149m.ESC[4;38;5;149mTestCase):
482 def test(self):
483 pass
484
485 self.assertIs(Foo('test').failureException, AssertionError)
486
487 # "This class attribute gives the exception raised by the test() method.
488 # If a test framework needs to use a specialized exception, possibly to
489 # carry additional information, it must subclass this exception in
490 # order to ``play fair'' with the framework."
491 #
492 # Make sure TestCase.run() respects the designated failureException
493 def test_failureException__subclassing__explicit_raise(self):
494 events = []
495 result = LoggingResult(events)
496
497 class ESC[4;38;5;81mFoo(ESC[4;38;5;149munittestESC[4;38;5;149m.ESC[4;38;5;149mTestCase):
498 def test(self):
499 raise RuntimeError()
500
501 failureException = RuntimeError
502
503 self.assertIs(Foo('test').failureException, RuntimeError)
504
505
506 Foo('test').run(result)
507 expected = ['startTest', 'addFailure', 'stopTest']
508 self.assertEqual(events, expected)
509
510 # "This class attribute gives the exception raised by the test() method.
511 # If a test framework needs to use a specialized exception, possibly to
512 # carry additional information, it must subclass this exception in
513 # order to ``play fair'' with the framework."
514 #
515 # Make sure TestCase.run() respects the designated failureException
516 def test_failureException__subclassing__implicit_raise(self):
517 events = []
518 result = LoggingResult(events)
519
520 class ESC[4;38;5;81mFoo(ESC[4;38;5;149munittestESC[4;38;5;149m.ESC[4;38;5;149mTestCase):
521 def test(self):
522 self.fail("foo")
523
524 failureException = RuntimeError
525
526 self.assertIs(Foo('test').failureException, RuntimeError)
527
528
529 Foo('test').run(result)
530 expected = ['startTest', 'addFailure', 'stopTest']
531 self.assertEqual(events, expected)
532
533 # "The default implementation does nothing."
534 def test_setUp(self):
535 class ESC[4;38;5;81mFoo(ESC[4;38;5;149munittestESC[4;38;5;149m.ESC[4;38;5;149mTestCase):
536 def runTest(self):
537 pass
538
539 # ... and nothing should happen
540 Foo().setUp()
541
542 # "The default implementation does nothing."
543 def test_tearDown(self):
544 class ESC[4;38;5;81mFoo(ESC[4;38;5;149munittestESC[4;38;5;149m.ESC[4;38;5;149mTestCase):
545 def runTest(self):
546 pass
547
548 # ... and nothing should happen
549 Foo().tearDown()
550
551 # "Return a string identifying the specific test case."
552 #
553 # Because of the vague nature of the docs, I'm not going to lock this
554 # test down too much. Really all that can be asserted is that the id()
555 # will be a string (either 8-byte or unicode -- again, because the docs
556 # just say "string")
557 def test_id(self):
558 class ESC[4;38;5;81mFoo(ESC[4;38;5;149munittestESC[4;38;5;149m.ESC[4;38;5;149mTestCase):
559 def runTest(self):
560 pass
561
562 self.assertIsInstance(Foo().id(), str)
563
564
565 # "If result is omitted or None, a temporary result object is created,
566 # used, and is made available to the caller. As TestCase owns the
567 # temporary result startTestRun and stopTestRun are called.
568
569 def test_run__uses_defaultTestResult(self):
570 events = []
571 defaultResult = LoggingResult(events)
572
573 class ESC[4;38;5;81mFoo(ESC[4;38;5;149munittestESC[4;38;5;149m.ESC[4;38;5;149mTestCase):
574 def test(self):
575 events.append('test')
576
577 def defaultTestResult(self):
578 return defaultResult
579
580 # Make run() find a result object on its own
581 result = Foo('test').run()
582
583 self.assertIs(result, defaultResult)
584 expected = ['startTestRun', 'startTest', 'test', 'addSuccess',
585 'stopTest', 'stopTestRun']
586 self.assertEqual(events, expected)
587
588
589 # "The result object is returned to run's caller"
590 def test_run__returns_given_result(self):
591
592 class ESC[4;38;5;81mFoo(ESC[4;38;5;149munittestESC[4;38;5;149m.ESC[4;38;5;149mTestCase):
593 def test(self):
594 pass
595
596 result = unittest.TestResult()
597
598 retval = Foo('test').run(result)
599 self.assertIs(retval, result)
600
601
602 # "The same effect [as method run] may be had by simply calling the
603 # TestCase instance."
604 def test_call__invoking_an_instance_delegates_to_run(self):
605 resultIn = unittest.TestResult()
606 resultOut = unittest.TestResult()
607
608 class ESC[4;38;5;81mFoo(ESC[4;38;5;149munittestESC[4;38;5;149m.ESC[4;38;5;149mTestCase):
609 def test(self):
610 pass
611
612 def run(self, result):
613 self.assertIs(result, resultIn)
614 return resultOut
615
616 retval = Foo('test')(resultIn)
617
618 self.assertIs(retval, resultOut)
619
620
621 def testShortDescriptionWithoutDocstring(self):
622 self.assertIsNone(self.shortDescription())
623
624 @unittest.skipIf(sys.flags.optimize >= 2,
625 "Docstrings are omitted with -O2 and above")
626 def testShortDescriptionWithOneLineDocstring(self):
627 """Tests shortDescription() for a method with a docstring."""
628 self.assertEqual(
629 self.shortDescription(),
630 'Tests shortDescription() for a method with a docstring.')
631
632 @unittest.skipIf(sys.flags.optimize >= 2,
633 "Docstrings are omitted with -O2 and above")
634 def testShortDescriptionWithMultiLineDocstring(self):
635 """Tests shortDescription() for a method with a longer docstring.
636
637 This method ensures that only the first line of a docstring is
638 returned used in the short description, no matter how long the
639 whole thing is.
640 """
641 self.assertEqual(
642 self.shortDescription(),
643 'Tests shortDescription() for a method with a longer '
644 'docstring.')
645
646 @unittest.skipIf(sys.flags.optimize >= 2,
647 "Docstrings are omitted with -O2 and above")
648 def testShortDescriptionWhitespaceTrimming(self):
649 """
650 Tests shortDescription() whitespace is trimmed, so that the first
651 line of nonwhite-space text becomes the docstring.
652 """
653 self.assertEqual(
654 self.shortDescription(),
655 'Tests shortDescription() whitespace is trimmed, so that the first')
656
657 def testAddTypeEqualityFunc(self):
658 class ESC[4;38;5;81mSadSnake(ESC[4;38;5;149mobject):
659 """Dummy class for test_addTypeEqualityFunc."""
660 s1, s2 = SadSnake(), SadSnake()
661 self.assertFalse(s1 == s2)
662 def AllSnakesCreatedEqual(a, b, msg=None):
663 return type(a) == type(b) == SadSnake
664 self.addTypeEqualityFunc(SadSnake, AllSnakesCreatedEqual)
665 self.assertEqual(s1, s2)
666 # No this doesn't clean up and remove the SadSnake equality func
667 # from this TestCase instance but since it's local nothing else
668 # will ever notice that.
669
670 def testAssertIs(self):
671 thing = object()
672 self.assertIs(thing, thing)
673 self.assertRaises(self.failureException, self.assertIs, thing, object())
674
675 def testAssertIsNot(self):
676 thing = object()
677 self.assertIsNot(thing, object())
678 self.assertRaises(self.failureException, self.assertIsNot, thing, thing)
679
680 def testAssertIsInstance(self):
681 thing = []
682 self.assertIsInstance(thing, list)
683 self.assertRaises(self.failureException, self.assertIsInstance,
684 thing, dict)
685
686 def testAssertNotIsInstance(self):
687 thing = []
688 self.assertNotIsInstance(thing, dict)
689 self.assertRaises(self.failureException, self.assertNotIsInstance,
690 thing, list)
691
692 def testAssertIn(self):
693 animals = {'monkey': 'banana', 'cow': 'grass', 'seal': 'fish'}
694
695 self.assertIn('a', 'abc')
696 self.assertIn(2, [1, 2, 3])
697 self.assertIn('monkey', animals)
698
699 self.assertNotIn('d', 'abc')
700 self.assertNotIn(0, [1, 2, 3])
701 self.assertNotIn('otter', animals)
702
703 self.assertRaises(self.failureException, self.assertIn, 'x', 'abc')
704 self.assertRaises(self.failureException, self.assertIn, 4, [1, 2, 3])
705 self.assertRaises(self.failureException, self.assertIn, 'elephant',
706 animals)
707
708 self.assertRaises(self.failureException, self.assertNotIn, 'c', 'abc')
709 self.assertRaises(self.failureException, self.assertNotIn, 1, [1, 2, 3])
710 self.assertRaises(self.failureException, self.assertNotIn, 'cow',
711 animals)
712
713 def testAssertEqual(self):
714 equal_pairs = [
715 ((), ()),
716 ({}, {}),
717 ([], []),
718 (set(), set()),
719 (frozenset(), frozenset())]
720 for a, b in equal_pairs:
721 # This mess of try excepts is to test the assertEqual behavior
722 # itself.
723 try:
724 self.assertEqual(a, b)
725 except self.failureException:
726 self.fail('assertEqual(%r, %r) failed' % (a, b))
727 try:
728 self.assertEqual(a, b, msg='foo')
729 except self.failureException:
730 self.fail('assertEqual(%r, %r) with msg= failed' % (a, b))
731 try:
732 self.assertEqual(a, b, 'foo')
733 except self.failureException:
734 self.fail('assertEqual(%r, %r) with third parameter failed' %
735 (a, b))
736
737 unequal_pairs = [
738 ((), []),
739 ({}, set()),
740 (set([4,1]), frozenset([4,2])),
741 (frozenset([4,5]), set([2,3])),
742 (set([3,4]), set([5,4]))]
743 for a, b in unequal_pairs:
744 self.assertRaises(self.failureException, self.assertEqual, a, b)
745 self.assertRaises(self.failureException, self.assertEqual, a, b,
746 'foo')
747 self.assertRaises(self.failureException, self.assertEqual, a, b,
748 msg='foo')
749
750 def testEquality(self):
751 self.assertListEqual([], [])
752 self.assertTupleEqual((), ())
753 self.assertSequenceEqual([], ())
754
755 a = [0, 'a', []]
756 b = []
757 self.assertRaises(unittest.TestCase.failureException,
758 self.assertListEqual, a, b)
759 self.assertRaises(unittest.TestCase.failureException,
760 self.assertListEqual, tuple(a), tuple(b))
761 self.assertRaises(unittest.TestCase.failureException,
762 self.assertSequenceEqual, a, tuple(b))
763
764 b.extend(a)
765 self.assertListEqual(a, b)
766 self.assertTupleEqual(tuple(a), tuple(b))
767 self.assertSequenceEqual(a, tuple(b))
768 self.assertSequenceEqual(tuple(a), b)
769
770 self.assertRaises(self.failureException, self.assertListEqual,
771 a, tuple(b))
772 self.assertRaises(self.failureException, self.assertTupleEqual,
773 tuple(a), b)
774 self.assertRaises(self.failureException, self.assertListEqual, None, b)
775 self.assertRaises(self.failureException, self.assertTupleEqual, None,
776 tuple(b))
777 self.assertRaises(self.failureException, self.assertSequenceEqual,
778 None, tuple(b))
779 self.assertRaises(self.failureException, self.assertListEqual, 1, 1)
780 self.assertRaises(self.failureException, self.assertTupleEqual, 1, 1)
781 self.assertRaises(self.failureException, self.assertSequenceEqual,
782 1, 1)
783
784 self.assertDictEqual({}, {})
785
786 c = { 'x': 1 }
787 d = {}
788 self.assertRaises(unittest.TestCase.failureException,
789 self.assertDictEqual, c, d)
790
791 d.update(c)
792 self.assertDictEqual(c, d)
793
794 d['x'] = 0
795 self.assertRaises(unittest.TestCase.failureException,
796 self.assertDictEqual, c, d, 'These are unequal')
797
798 self.assertRaises(self.failureException, self.assertDictEqual, None, d)
799 self.assertRaises(self.failureException, self.assertDictEqual, [], d)
800 self.assertRaises(self.failureException, self.assertDictEqual, 1, 1)
801
802 def testAssertSequenceEqualMaxDiff(self):
803 self.assertEqual(self.maxDiff, 80*8)
804 seq1 = 'a' + 'x' * 80**2
805 seq2 = 'b' + 'x' * 80**2
806 diff = '\n'.join(difflib.ndiff(pprint.pformat(seq1).splitlines(),
807 pprint.pformat(seq2).splitlines()))
808 # the +1 is the leading \n added by assertSequenceEqual
809 omitted = unittest.case.DIFF_OMITTED % (len(diff) + 1,)
810
811 self.maxDiff = len(diff)//2
812 try:
813
814 self.assertSequenceEqual(seq1, seq2)
815 except self.failureException as e:
816 msg = e.args[0]
817 else:
818 self.fail('assertSequenceEqual did not fail.')
819 self.assertLess(len(msg), len(diff))
820 self.assertIn(omitted, msg)
821
822 self.maxDiff = len(diff) * 2
823 try:
824 self.assertSequenceEqual(seq1, seq2)
825 except self.failureException as e:
826 msg = e.args[0]
827 else:
828 self.fail('assertSequenceEqual did not fail.')
829 self.assertGreater(len(msg), len(diff))
830 self.assertNotIn(omitted, msg)
831
832 self.maxDiff = None
833 try:
834 self.assertSequenceEqual(seq1, seq2)
835 except self.failureException as e:
836 msg = e.args[0]
837 else:
838 self.fail('assertSequenceEqual did not fail.')
839 self.assertGreater(len(msg), len(diff))
840 self.assertNotIn(omitted, msg)
841
842 def testTruncateMessage(self):
843 self.maxDiff = 1
844 message = self._truncateMessage('foo', 'bar')
845 omitted = unittest.case.DIFF_OMITTED % len('bar')
846 self.assertEqual(message, 'foo' + omitted)
847
848 self.maxDiff = None
849 message = self._truncateMessage('foo', 'bar')
850 self.assertEqual(message, 'foobar')
851
852 self.maxDiff = 4
853 message = self._truncateMessage('foo', 'bar')
854 self.assertEqual(message, 'foobar')
855
856 def testAssertDictEqualTruncates(self):
857 test = unittest.TestCase('assertEqual')
858 def truncate(msg, diff):
859 return 'foo'
860 test._truncateMessage = truncate
861 try:
862 test.assertDictEqual({}, {1: 0})
863 except self.failureException as e:
864 self.assertEqual(str(e), 'foo')
865 else:
866 self.fail('assertDictEqual did not fail')
867
868 def testAssertMultiLineEqualTruncates(self):
869 test = unittest.TestCase('assertEqual')
870 def truncate(msg, diff):
871 return 'foo'
872 test._truncateMessage = truncate
873 try:
874 test.assertMultiLineEqual('foo', 'bar')
875 except self.failureException as e:
876 self.assertEqual(str(e), 'foo')
877 else:
878 self.fail('assertMultiLineEqual did not fail')
879
880 def testAssertEqual_diffThreshold(self):
881 # check threshold value
882 self.assertEqual(self._diffThreshold, 2**16)
883 # disable madDiff to get diff markers
884 self.maxDiff = None
885
886 # set a lower threshold value and add a cleanup to restore it
887 old_threshold = self._diffThreshold
888 self._diffThreshold = 2**5
889 self.addCleanup(lambda: setattr(self, '_diffThreshold', old_threshold))
890
891 # under the threshold: diff marker (^) in error message
892 s = 'x' * (2**4)
893 with self.assertRaises(self.failureException) as cm:
894 self.assertEqual(s + 'a', s + 'b')
895 self.assertIn('^', str(cm.exception))
896 self.assertEqual(s + 'a', s + 'a')
897
898 # over the threshold: diff not used and marker (^) not in error message
899 s = 'x' * (2**6)
900 # if the path that uses difflib is taken, _truncateMessage will be
901 # called -- replace it with explodingTruncation to verify that this
902 # doesn't happen
903 def explodingTruncation(message, diff):
904 raise SystemError('this should not be raised')
905 old_truncate = self._truncateMessage
906 self._truncateMessage = explodingTruncation
907 self.addCleanup(lambda: setattr(self, '_truncateMessage', old_truncate))
908
909 s1, s2 = s + 'a', s + 'b'
910 with self.assertRaises(self.failureException) as cm:
911 self.assertEqual(s1, s2)
912 self.assertNotIn('^', str(cm.exception))
913 self.assertEqual(str(cm.exception), '%r != %r' % (s1, s2))
914 self.assertEqual(s + 'a', s + 'a')
915
916 def testAssertEqual_shorten(self):
917 # set a lower threshold value and add a cleanup to restore it
918 old_threshold = self._diffThreshold
919 self._diffThreshold = 0
920 self.addCleanup(lambda: setattr(self, '_diffThreshold', old_threshold))
921
922 s = 'x' * 100
923 s1, s2 = s + 'a', s + 'b'
924 with self.assertRaises(self.failureException) as cm:
925 self.assertEqual(s1, s2)
926 c = 'xxxx[35 chars]' + 'x' * 61
927 self.assertEqual(str(cm.exception), "'%sa' != '%sb'" % (c, c))
928 self.assertEqual(s + 'a', s + 'a')
929
930 p = 'y' * 50
931 s1, s2 = s + 'a' + p, s + 'b' + p
932 with self.assertRaises(self.failureException) as cm:
933 self.assertEqual(s1, s2)
934 c = 'xxxx[85 chars]xxxxxxxxxxx'
935 self.assertEqual(str(cm.exception), "'%sa%s' != '%sb%s'" % (c, p, c, p))
936
937 p = 'y' * 100
938 s1, s2 = s + 'a' + p, s + 'b' + p
939 with self.assertRaises(self.failureException) as cm:
940 self.assertEqual(s1, s2)
941 c = 'xxxx[91 chars]xxxxx'
942 d = 'y' * 40 + '[56 chars]yyyy'
943 self.assertEqual(str(cm.exception), "'%sa%s' != '%sb%s'" % (c, d, c, d))
944
945 def testAssertCountEqual(self):
946 a = object()
947 self.assertCountEqual([1, 2, 3], [3, 2, 1])
948 self.assertCountEqual(['foo', 'bar', 'baz'], ['bar', 'baz', 'foo'])
949 self.assertCountEqual([a, a, 2, 2, 3], (a, 2, 3, a, 2))
950 self.assertCountEqual([1, "2", "a", "a"], ["a", "2", True, "a"])
951 self.assertRaises(self.failureException, self.assertCountEqual,
952 [1, 2] + [3] * 100, [1] * 100 + [2, 3])
953 self.assertRaises(self.failureException, self.assertCountEqual,
954 [1, "2", "a", "a"], ["a", "2", True, 1])
955 self.assertRaises(self.failureException, self.assertCountEqual,
956 [10], [10, 11])
957 self.assertRaises(self.failureException, self.assertCountEqual,
958 [10, 11], [10])
959 self.assertRaises(self.failureException, self.assertCountEqual,
960 [10, 11, 10], [10, 11])
961
962 # Test that sequences of unhashable objects can be tested for sameness:
963 self.assertCountEqual([[1, 2], [3, 4], 0], [False, [3, 4], [1, 2]])
964 # Test that iterator of unhashable objects can be tested for sameness:
965 self.assertCountEqual(iter([1, 2, [], 3, 4]),
966 iter([1, 2, [], 3, 4]))
967
968 # hashable types, but not orderable
969 self.assertRaises(self.failureException, self.assertCountEqual,
970 [], [divmod, 'x', 1, 5j, 2j, frozenset()])
971 # comparing dicts
972 self.assertCountEqual([{'a': 1}, {'b': 2}], [{'b': 2}, {'a': 1}])
973 # comparing heterogeneous non-hashable sequences
974 self.assertCountEqual([1, 'x', divmod, []], [divmod, [], 'x', 1])
975 self.assertRaises(self.failureException, self.assertCountEqual,
976 [], [divmod, [], 'x', 1, 5j, 2j, set()])
977 self.assertRaises(self.failureException, self.assertCountEqual,
978 [[1]], [[2]])
979
980 # Same elements, but not same sequence length
981 self.assertRaises(self.failureException, self.assertCountEqual,
982 [1, 1, 2], [2, 1])
983 self.assertRaises(self.failureException, self.assertCountEqual,
984 [1, 1, "2", "a", "a"], ["2", "2", True, "a"])
985 self.assertRaises(self.failureException, self.assertCountEqual,
986 [1, {'b': 2}, None, True], [{'b': 2}, True, None])
987
988 # Same elements which don't reliably compare, in
989 # different order, see issue 10242
990 a = [{2,4}, {1,2}]
991 b = a[::-1]
992 self.assertCountEqual(a, b)
993
994 # test utility functions supporting assertCountEqual()
995
996 diffs = set(unittest.util._count_diff_all_purpose('aaabccd', 'abbbcce'))
997 expected = {(3,1,'a'), (1,3,'b'), (1,0,'d'), (0,1,'e')}
998 self.assertEqual(diffs, expected)
999
1000 diffs = unittest.util._count_diff_all_purpose([[]], [])
1001 self.assertEqual(diffs, [(1, 0, [])])
1002
1003 diffs = set(unittest.util._count_diff_hashable('aaabccd', 'abbbcce'))
1004 expected = {(3,1,'a'), (1,3,'b'), (1,0,'d'), (0,1,'e')}
1005 self.assertEqual(diffs, expected)
1006
1007 def testAssertSetEqual(self):
1008 set1 = set()
1009 set2 = set()
1010 self.assertSetEqual(set1, set2)
1011
1012 self.assertRaises(self.failureException, self.assertSetEqual, None, set2)
1013 self.assertRaises(self.failureException, self.assertSetEqual, [], set2)
1014 self.assertRaises(self.failureException, self.assertSetEqual, set1, None)
1015 self.assertRaises(self.failureException, self.assertSetEqual, set1, [])
1016
1017 set1 = set(['a'])
1018 set2 = set()
1019 self.assertRaises(self.failureException, self.assertSetEqual, set1, set2)
1020
1021 set1 = set(['a'])
1022 set2 = set(['a'])
1023 self.assertSetEqual(set1, set2)
1024
1025 set1 = set(['a'])
1026 set2 = set(['a', 'b'])
1027 self.assertRaises(self.failureException, self.assertSetEqual, set1, set2)
1028
1029 set1 = set(['a'])
1030 set2 = frozenset(['a', 'b'])
1031 self.assertRaises(self.failureException, self.assertSetEqual, set1, set2)
1032
1033 set1 = set(['a', 'b'])
1034 set2 = frozenset(['a', 'b'])
1035 self.assertSetEqual(set1, set2)
1036
1037 set1 = set()
1038 set2 = "foo"
1039 self.assertRaises(self.failureException, self.assertSetEqual, set1, set2)
1040 self.assertRaises(self.failureException, self.assertSetEqual, set2, set1)
1041
1042 # make sure any string formatting is tuple-safe
1043 set1 = set([(0, 1), (2, 3)])
1044 set2 = set([(4, 5)])
1045 self.assertRaises(self.failureException, self.assertSetEqual, set1, set2)
1046
1047 def testInequality(self):
1048 # Try ints
1049 self.assertGreater(2, 1)
1050 self.assertGreaterEqual(2, 1)
1051 self.assertGreaterEqual(1, 1)
1052 self.assertLess(1, 2)
1053 self.assertLessEqual(1, 2)
1054 self.assertLessEqual(1, 1)
1055 self.assertRaises(self.failureException, self.assertGreater, 1, 2)
1056 self.assertRaises(self.failureException, self.assertGreater, 1, 1)
1057 self.assertRaises(self.failureException, self.assertGreaterEqual, 1, 2)
1058 self.assertRaises(self.failureException, self.assertLess, 2, 1)
1059 self.assertRaises(self.failureException, self.assertLess, 1, 1)
1060 self.assertRaises(self.failureException, self.assertLessEqual, 2, 1)
1061
1062 # Try Floats
1063 self.assertGreater(1.1, 1.0)
1064 self.assertGreaterEqual(1.1, 1.0)
1065 self.assertGreaterEqual(1.0, 1.0)
1066 self.assertLess(1.0, 1.1)
1067 self.assertLessEqual(1.0, 1.1)
1068 self.assertLessEqual(1.0, 1.0)
1069 self.assertRaises(self.failureException, self.assertGreater, 1.0, 1.1)
1070 self.assertRaises(self.failureException, self.assertGreater, 1.0, 1.0)
1071 self.assertRaises(self.failureException, self.assertGreaterEqual, 1.0, 1.1)
1072 self.assertRaises(self.failureException, self.assertLess, 1.1, 1.0)
1073 self.assertRaises(self.failureException, self.assertLess, 1.0, 1.0)
1074 self.assertRaises(self.failureException, self.assertLessEqual, 1.1, 1.0)
1075
1076 # Try Strings
1077 self.assertGreater('bug', 'ant')
1078 self.assertGreaterEqual('bug', 'ant')
1079 self.assertGreaterEqual('ant', 'ant')
1080 self.assertLess('ant', 'bug')
1081 self.assertLessEqual('ant', 'bug')
1082 self.assertLessEqual('ant', 'ant')
1083 self.assertRaises(self.failureException, self.assertGreater, 'ant', 'bug')
1084 self.assertRaises(self.failureException, self.assertGreater, 'ant', 'ant')
1085 self.assertRaises(self.failureException, self.assertGreaterEqual, 'ant', 'bug')
1086 self.assertRaises(self.failureException, self.assertLess, 'bug', 'ant')
1087 self.assertRaises(self.failureException, self.assertLess, 'ant', 'ant')
1088 self.assertRaises(self.failureException, self.assertLessEqual, 'bug', 'ant')
1089
1090 # Try bytes
1091 self.assertGreater(b'bug', b'ant')
1092 self.assertGreaterEqual(b'bug', b'ant')
1093 self.assertGreaterEqual(b'ant', b'ant')
1094 self.assertLess(b'ant', b'bug')
1095 self.assertLessEqual(b'ant', b'bug')
1096 self.assertLessEqual(b'ant', b'ant')
1097 self.assertRaises(self.failureException, self.assertGreater, b'ant', b'bug')
1098 self.assertRaises(self.failureException, self.assertGreater, b'ant', b'ant')
1099 self.assertRaises(self.failureException, self.assertGreaterEqual, b'ant',
1100 b'bug')
1101 self.assertRaises(self.failureException, self.assertLess, b'bug', b'ant')
1102 self.assertRaises(self.failureException, self.assertLess, b'ant', b'ant')
1103 self.assertRaises(self.failureException, self.assertLessEqual, b'bug', b'ant')
1104
1105 def testAssertMultiLineEqual(self):
1106 sample_text = """\
1107 http://www.python.org/doc/2.3/lib/module-unittest.html
1108 test case
1109 A test case is the smallest unit of testing. [...]
1110 """
1111 revised_sample_text = """\
1112 http://www.python.org/doc/2.4.1/lib/module-unittest.html
1113 test case
1114 A test case is the smallest unit of testing. [...] You may provide your
1115 own implementation that does not subclass from TestCase, of course.
1116 """
1117 sample_text_error = """\
1118 - http://www.python.org/doc/2.3/lib/module-unittest.html
1119 ? ^
1120 + http://www.python.org/doc/2.4.1/lib/module-unittest.html
1121 ? ^^^
1122 test case
1123 - A test case is the smallest unit of testing. [...]
1124 + A test case is the smallest unit of testing. [...] You may provide your
1125 ? +++++++++++++++++++++
1126 + own implementation that does not subclass from TestCase, of course.
1127 """
1128 self.maxDiff = None
1129 try:
1130 self.assertMultiLineEqual(sample_text, revised_sample_text)
1131 except self.failureException as e:
1132 # need to remove the first line of the error message
1133 error = str(e).split('\n', 1)[1]
1134 self.assertEqual(sample_text_error, error)
1135
1136 def testAssertEqualSingleLine(self):
1137 sample_text = "laden swallows fly slowly"
1138 revised_sample_text = "unladen swallows fly quickly"
1139 sample_text_error = """\
1140 - laden swallows fly slowly
1141 ? ^^^^
1142 + unladen swallows fly quickly
1143 ? ++ ^^^^^
1144 """
1145 try:
1146 self.assertEqual(sample_text, revised_sample_text)
1147 except self.failureException as e:
1148 # need to remove the first line of the error message
1149 error = str(e).split('\n', 1)[1]
1150 self.assertEqual(sample_text_error, error)
1151
1152 def testAssertEqualwithEmptyString(self):
1153 '''Verify when there is an empty string involved, the diff output
1154 does not treat the empty string as a single empty line. It should
1155 instead be handled as a non-line.
1156 '''
1157 sample_text = ''
1158 revised_sample_text = 'unladen swallows fly quickly'
1159 sample_text_error = '''\
1160 + unladen swallows fly quickly
1161 '''
1162 try:
1163 self.assertEqual(sample_text, revised_sample_text)
1164 except self.failureException as e:
1165 # need to remove the first line of the error message
1166 error = str(e).split('\n', 1)[1]
1167 self.assertEqual(sample_text_error, error)
1168
1169 def testAssertEqualMultipleLinesMissingNewlineTerminator(self):
1170 '''Verifying format of diff output from assertEqual involving strings
1171 with multiple lines, but missing the terminating newline on both.
1172 '''
1173 sample_text = 'laden swallows\nfly sloely'
1174 revised_sample_text = 'laden swallows\nfly slowly'
1175 sample_text_error = '''\
1176 laden swallows
1177 - fly sloely
1178 ? ^
1179 + fly slowly
1180 ? ^
1181 '''
1182 try:
1183 self.assertEqual(sample_text, revised_sample_text)
1184 except self.failureException as e:
1185 # need to remove the first line of the error message
1186 error = str(e).split('\n', 1)[1]
1187 self.assertEqual(sample_text_error, error)
1188
1189 def testAssertEqualMultipleLinesMismatchedNewlinesTerminators(self):
1190 '''Verifying format of diff output from assertEqual involving strings
1191 with multiple lines and mismatched newlines. The output should
1192 include a - on it's own line to indicate the newline difference
1193 between the two strings
1194 '''
1195 sample_text = 'laden swallows\nfly sloely\n'
1196 revised_sample_text = 'laden swallows\nfly slowly'
1197 sample_text_error = '''\
1198 laden swallows
1199 - fly sloely
1200 ? ^
1201 + fly slowly
1202 ? ^
1203 -\x20
1204 '''
1205 try:
1206 self.assertEqual(sample_text, revised_sample_text)
1207 except self.failureException as e:
1208 # need to remove the first line of the error message
1209 error = str(e).split('\n', 1)[1]
1210 self.assertEqual(sample_text_error, error)
1211
1212 def testEqualityBytesWarning(self):
1213 if sys.flags.bytes_warning:
1214 def bytes_warning():
1215 return self.assertWarnsRegex(BytesWarning,
1216 'Comparison between bytes and string')
1217 else:
1218 def bytes_warning():
1219 return contextlib.ExitStack()
1220
1221 with bytes_warning(), self.assertRaises(self.failureException):
1222 self.assertEqual('a', b'a')
1223 with bytes_warning():
1224 self.assertNotEqual('a', b'a')
1225
1226 a = [0, 'a']
1227 b = [0, b'a']
1228 with bytes_warning(), self.assertRaises(self.failureException):
1229 self.assertListEqual(a, b)
1230 with bytes_warning(), self.assertRaises(self.failureException):
1231 self.assertTupleEqual(tuple(a), tuple(b))
1232 with bytes_warning(), self.assertRaises(self.failureException):
1233 self.assertSequenceEqual(a, tuple(b))
1234 with bytes_warning(), self.assertRaises(self.failureException):
1235 self.assertSequenceEqual(tuple(a), b)
1236 with bytes_warning(), self.assertRaises(self.failureException):
1237 self.assertSequenceEqual('a', b'a')
1238 with bytes_warning(), self.assertRaises(self.failureException):
1239 self.assertSetEqual(set(a), set(b))
1240
1241 with self.assertRaises(self.failureException):
1242 self.assertListEqual(a, tuple(b))
1243 with self.assertRaises(self.failureException):
1244 self.assertTupleEqual(tuple(a), b)
1245
1246 a = [0, b'a']
1247 b = [0]
1248 with self.assertRaises(self.failureException):
1249 self.assertListEqual(a, b)
1250 with self.assertRaises(self.failureException):
1251 self.assertTupleEqual(tuple(a), tuple(b))
1252 with self.assertRaises(self.failureException):
1253 self.assertSequenceEqual(a, tuple(b))
1254 with self.assertRaises(self.failureException):
1255 self.assertSequenceEqual(tuple(a), b)
1256 with self.assertRaises(self.failureException):
1257 self.assertSetEqual(set(a), set(b))
1258
1259 a = [0]
1260 b = [0, b'a']
1261 with self.assertRaises(self.failureException):
1262 self.assertListEqual(a, b)
1263 with self.assertRaises(self.failureException):
1264 self.assertTupleEqual(tuple(a), tuple(b))
1265 with self.assertRaises(self.failureException):
1266 self.assertSequenceEqual(a, tuple(b))
1267 with self.assertRaises(self.failureException):
1268 self.assertSequenceEqual(tuple(a), b)
1269 with self.assertRaises(self.failureException):
1270 self.assertSetEqual(set(a), set(b))
1271
1272 with bytes_warning(), self.assertRaises(self.failureException):
1273 self.assertDictEqual({'a': 0}, {b'a': 0})
1274 with self.assertRaises(self.failureException):
1275 self.assertDictEqual({}, {b'a': 0})
1276 with self.assertRaises(self.failureException):
1277 self.assertDictEqual({b'a': 0}, {})
1278
1279 with self.assertRaises(self.failureException):
1280 self.assertCountEqual([b'a', b'a'], [b'a', b'a', b'a'])
1281 with bytes_warning():
1282 self.assertCountEqual(['a', b'a'], ['a', b'a'])
1283 with bytes_warning(), self.assertRaises(self.failureException):
1284 self.assertCountEqual(['a', 'a'], [b'a', b'a'])
1285 with bytes_warning(), self.assertRaises(self.failureException):
1286 self.assertCountEqual(['a', 'a', []], [b'a', b'a', []])
1287
1288 def testAssertIsNone(self):
1289 self.assertIsNone(None)
1290 self.assertRaises(self.failureException, self.assertIsNone, False)
1291 self.assertIsNotNone('DjZoPloGears on Rails')
1292 self.assertRaises(self.failureException, self.assertIsNotNone, None)
1293
1294 def testAssertRegex(self):
1295 self.assertRegex('asdfabasdf', r'ab+')
1296 self.assertRaises(self.failureException, self.assertRegex,
1297 'saaas', r'aaaa')
1298
1299 def testAssertRaisesCallable(self):
1300 class ESC[4;38;5;81mExceptionMock(ESC[4;38;5;149mException):
1301 pass
1302 def Stub():
1303 raise ExceptionMock('We expect')
1304 self.assertRaises(ExceptionMock, Stub)
1305 # A tuple of exception classes is accepted
1306 self.assertRaises((ValueError, ExceptionMock), Stub)
1307 # *args and **kwargs also work
1308 self.assertRaises(ValueError, int, '19', base=8)
1309 # Failure when no exception is raised
1310 with self.assertRaises(self.failureException):
1311 self.assertRaises(ExceptionMock, lambda: 0)
1312 # Failure when the function is None
1313 with self.assertRaises(TypeError):
1314 self.assertRaises(ExceptionMock, None)
1315 # Failure when another exception is raised
1316 with self.assertRaises(ExceptionMock):
1317 self.assertRaises(ValueError, Stub)
1318
1319 def testAssertRaisesContext(self):
1320 class ESC[4;38;5;81mExceptionMock(ESC[4;38;5;149mException):
1321 pass
1322 def Stub():
1323 raise ExceptionMock('We expect')
1324 with self.assertRaises(ExceptionMock):
1325 Stub()
1326 # A tuple of exception classes is accepted
1327 with self.assertRaises((ValueError, ExceptionMock)) as cm:
1328 Stub()
1329 # The context manager exposes caught exception
1330 self.assertIsInstance(cm.exception, ExceptionMock)
1331 self.assertEqual(cm.exception.args[0], 'We expect')
1332 # *args and **kwargs also work
1333 with self.assertRaises(ValueError):
1334 int('19', base=8)
1335 # Failure when no exception is raised
1336 with self.assertRaises(self.failureException):
1337 with self.assertRaises(ExceptionMock):
1338 pass
1339 # Custom message
1340 with self.assertRaisesRegex(self.failureException, 'foobar'):
1341 with self.assertRaises(ExceptionMock, msg='foobar'):
1342 pass
1343 # Invalid keyword argument
1344 with self.assertRaisesRegex(TypeError, 'foobar'):
1345 with self.assertRaises(ExceptionMock, foobar=42):
1346 pass
1347 # Failure when another exception is raised
1348 with self.assertRaises(ExceptionMock):
1349 self.assertRaises(ValueError, Stub)
1350
1351 def testAssertRaisesNoExceptionType(self):
1352 with self.assertRaises(TypeError):
1353 self.assertRaises()
1354 with self.assertRaises(TypeError):
1355 self.assertRaises(1)
1356 with self.assertRaises(TypeError):
1357 self.assertRaises(object)
1358 with self.assertRaises(TypeError):
1359 self.assertRaises((ValueError, 1))
1360 with self.assertRaises(TypeError):
1361 self.assertRaises((ValueError, object))
1362
1363 def testAssertRaisesRefcount(self):
1364 # bpo-23890: assertRaises() must not keep objects alive longer
1365 # than expected
1366 def func() :
1367 try:
1368 raise ValueError
1369 except ValueError:
1370 raise ValueError
1371
1372 refcount = sys.getrefcount(func)
1373 self.assertRaises(ValueError, func)
1374 self.assertEqual(refcount, sys.getrefcount(func))
1375
1376 def testAssertRaisesRegex(self):
1377 class ESC[4;38;5;81mExceptionMock(ESC[4;38;5;149mException):
1378 pass
1379
1380 def Stub():
1381 raise ExceptionMock('We expect')
1382
1383 self.assertRaisesRegex(ExceptionMock, re.compile('expect$'), Stub)
1384 self.assertRaisesRegex(ExceptionMock, 'expect$', Stub)
1385 with self.assertRaises(TypeError):
1386 self.assertRaisesRegex(ExceptionMock, 'expect$', None)
1387
1388 def testAssertNotRaisesRegex(self):
1389 self.assertRaisesRegex(
1390 self.failureException, '^Exception not raised by <lambda>$',
1391 self.assertRaisesRegex, Exception, re.compile('x'),
1392 lambda: None)
1393 self.assertRaisesRegex(
1394 self.failureException, '^Exception not raised by <lambda>$',
1395 self.assertRaisesRegex, Exception, 'x',
1396 lambda: None)
1397 # Custom message
1398 with self.assertRaisesRegex(self.failureException, 'foobar'):
1399 with self.assertRaisesRegex(Exception, 'expect', msg='foobar'):
1400 pass
1401 # Invalid keyword argument
1402 with self.assertRaisesRegex(TypeError, 'foobar'):
1403 with self.assertRaisesRegex(Exception, 'expect', foobar=42):
1404 pass
1405
1406 def testAssertRaisesRegexInvalidRegex(self):
1407 # Issue 20145.
1408 class ESC[4;38;5;81mMyExc(ESC[4;38;5;149mException):
1409 pass
1410 self.assertRaises(TypeError, self.assertRaisesRegex, MyExc, lambda: True)
1411
1412 def testAssertWarnsRegexInvalidRegex(self):
1413 # Issue 20145.
1414 class ESC[4;38;5;81mMyWarn(ESC[4;38;5;149mWarning):
1415 pass
1416 self.assertRaises(TypeError, self.assertWarnsRegex, MyWarn, lambda: True)
1417
1418 def testAssertWarnsModifySysModules(self):
1419 # bpo-29620: handle modified sys.modules during iteration
1420 class ESC[4;38;5;81mFoo(ESC[4;38;5;149mtypesESC[4;38;5;149m.ESC[4;38;5;149mModuleType):
1421 @property
1422 def __warningregistry__(self):
1423 sys.modules['@bar@'] = 'bar'
1424
1425 sys.modules['@foo@'] = Foo('foo')
1426 try:
1427 self.assertWarns(UserWarning, warnings.warn, 'expected')
1428 finally:
1429 del sys.modules['@foo@']
1430 del sys.modules['@bar@']
1431
1432 def testAssertRaisesRegexMismatch(self):
1433 def Stub():
1434 raise Exception('Unexpected')
1435
1436 self.assertRaisesRegex(
1437 self.failureException,
1438 r'"\^Expected\$" does not match "Unexpected"',
1439 self.assertRaisesRegex, Exception, '^Expected$',
1440 Stub)
1441 self.assertRaisesRegex(
1442 self.failureException,
1443 r'"\^Expected\$" does not match "Unexpected"',
1444 self.assertRaisesRegex, Exception,
1445 re.compile('^Expected$'), Stub)
1446
1447 def testAssertRaisesExcValue(self):
1448 class ESC[4;38;5;81mExceptionMock(ESC[4;38;5;149mException):
1449 pass
1450
1451 def Stub(foo):
1452 raise ExceptionMock(foo)
1453 v = "particular value"
1454
1455 ctx = self.assertRaises(ExceptionMock)
1456 with ctx:
1457 Stub(v)
1458 e = ctx.exception
1459 self.assertIsInstance(e, ExceptionMock)
1460 self.assertEqual(e.args[0], v)
1461
1462 def testAssertRaisesRegexNoExceptionType(self):
1463 with self.assertRaises(TypeError):
1464 self.assertRaisesRegex()
1465 with self.assertRaises(TypeError):
1466 self.assertRaisesRegex(ValueError)
1467 with self.assertRaises(TypeError):
1468 self.assertRaisesRegex(1, 'expect')
1469 with self.assertRaises(TypeError):
1470 self.assertRaisesRegex(object, 'expect')
1471 with self.assertRaises(TypeError):
1472 self.assertRaisesRegex((ValueError, 1), 'expect')
1473 with self.assertRaises(TypeError):
1474 self.assertRaisesRegex((ValueError, object), 'expect')
1475
1476 def testAssertWarnsCallable(self):
1477 def _runtime_warn():
1478 warnings.warn("foo", RuntimeWarning)
1479 # Success when the right warning is triggered, even several times
1480 self.assertWarns(RuntimeWarning, _runtime_warn)
1481 self.assertWarns(RuntimeWarning, _runtime_warn)
1482 # A tuple of warning classes is accepted
1483 self.assertWarns((DeprecationWarning, RuntimeWarning), _runtime_warn)
1484 # *args and **kwargs also work
1485 self.assertWarns(RuntimeWarning,
1486 warnings.warn, "foo", category=RuntimeWarning)
1487 # Failure when no warning is triggered
1488 with self.assertRaises(self.failureException):
1489 self.assertWarns(RuntimeWarning, lambda: 0)
1490 # Failure when the function is None
1491 with self.assertRaises(TypeError):
1492 self.assertWarns(RuntimeWarning, None)
1493 # Failure when another warning is triggered
1494 with warnings.catch_warnings():
1495 # Force default filter (in case tests are run with -We)
1496 warnings.simplefilter("default", RuntimeWarning)
1497 with self.assertRaises(self.failureException):
1498 self.assertWarns(DeprecationWarning, _runtime_warn)
1499 # Filters for other warnings are not modified
1500 with warnings.catch_warnings():
1501 warnings.simplefilter("error", RuntimeWarning)
1502 with self.assertRaises(RuntimeWarning):
1503 self.assertWarns(DeprecationWarning, _runtime_warn)
1504
1505 def testAssertWarnsContext(self):
1506 # Believe it or not, it is preferable to duplicate all tests above,
1507 # to make sure the __warningregistry__ $@ is circumvented correctly.
1508 def _runtime_warn():
1509 warnings.warn("foo", RuntimeWarning)
1510 _runtime_warn_lineno = inspect.getsourcelines(_runtime_warn)[1]
1511 with self.assertWarns(RuntimeWarning) as cm:
1512 _runtime_warn()
1513 # A tuple of warning classes is accepted
1514 with self.assertWarns((DeprecationWarning, RuntimeWarning)) as cm:
1515 _runtime_warn()
1516 # The context manager exposes various useful attributes
1517 self.assertIsInstance(cm.warning, RuntimeWarning)
1518 self.assertEqual(cm.warning.args[0], "foo")
1519 self.assertIn("test_case.py", cm.filename)
1520 self.assertEqual(cm.lineno, _runtime_warn_lineno + 1)
1521 # Same with several warnings
1522 with self.assertWarns(RuntimeWarning):
1523 _runtime_warn()
1524 _runtime_warn()
1525 with self.assertWarns(RuntimeWarning):
1526 warnings.warn("foo", category=RuntimeWarning)
1527 # Failure when no warning is triggered
1528 with self.assertRaises(self.failureException):
1529 with self.assertWarns(RuntimeWarning):
1530 pass
1531 # Custom message
1532 with self.assertRaisesRegex(self.failureException, 'foobar'):
1533 with self.assertWarns(RuntimeWarning, msg='foobar'):
1534 pass
1535 # Invalid keyword argument
1536 with self.assertRaisesRegex(TypeError, 'foobar'):
1537 with self.assertWarns(RuntimeWarning, foobar=42):
1538 pass
1539 # Failure when another warning is triggered
1540 with warnings.catch_warnings():
1541 # Force default filter (in case tests are run with -We)
1542 warnings.simplefilter("default", RuntimeWarning)
1543 with self.assertRaises(self.failureException):
1544 with self.assertWarns(DeprecationWarning):
1545 _runtime_warn()
1546 # Filters for other warnings are not modified
1547 with warnings.catch_warnings():
1548 warnings.simplefilter("error", RuntimeWarning)
1549 with self.assertRaises(RuntimeWarning):
1550 with self.assertWarns(DeprecationWarning):
1551 _runtime_warn()
1552
1553 def testAssertWarnsNoExceptionType(self):
1554 with self.assertRaises(TypeError):
1555 self.assertWarns()
1556 with self.assertRaises(TypeError):
1557 self.assertWarns(1)
1558 with self.assertRaises(TypeError):
1559 self.assertWarns(object)
1560 with self.assertRaises(TypeError):
1561 self.assertWarns((UserWarning, 1))
1562 with self.assertRaises(TypeError):
1563 self.assertWarns((UserWarning, object))
1564 with self.assertRaises(TypeError):
1565 self.assertWarns((UserWarning, Exception))
1566
1567 def testAssertWarnsRegexCallable(self):
1568 def _runtime_warn(msg):
1569 warnings.warn(msg, RuntimeWarning)
1570 self.assertWarnsRegex(RuntimeWarning, "o+",
1571 _runtime_warn, "foox")
1572 # Failure when no warning is triggered
1573 with self.assertRaises(self.failureException):
1574 self.assertWarnsRegex(RuntimeWarning, "o+",
1575 lambda: 0)
1576 # Failure when the function is None
1577 with self.assertRaises(TypeError):
1578 self.assertWarnsRegex(RuntimeWarning, "o+", None)
1579 # Failure when another warning is triggered
1580 with warnings.catch_warnings():
1581 # Force default filter (in case tests are run with -We)
1582 warnings.simplefilter("default", RuntimeWarning)
1583 with self.assertRaises(self.failureException):
1584 self.assertWarnsRegex(DeprecationWarning, "o+",
1585 _runtime_warn, "foox")
1586 # Failure when message doesn't match
1587 with self.assertRaises(self.failureException):
1588 self.assertWarnsRegex(RuntimeWarning, "o+",
1589 _runtime_warn, "barz")
1590 # A little trickier: we ask RuntimeWarnings to be raised, and then
1591 # check for some of them. It is implementation-defined whether
1592 # non-matching RuntimeWarnings are simply re-raised, or produce a
1593 # failureException.
1594 with warnings.catch_warnings():
1595 warnings.simplefilter("error", RuntimeWarning)
1596 with self.assertRaises((RuntimeWarning, self.failureException)):
1597 self.assertWarnsRegex(RuntimeWarning, "o+",
1598 _runtime_warn, "barz")
1599
1600 def testAssertWarnsRegexContext(self):
1601 # Same as above, but with assertWarnsRegex as a context manager
1602 def _runtime_warn(msg):
1603 warnings.warn(msg, RuntimeWarning)
1604 _runtime_warn_lineno = inspect.getsourcelines(_runtime_warn)[1]
1605 with self.assertWarnsRegex(RuntimeWarning, "o+") as cm:
1606 _runtime_warn("foox")
1607 self.assertIsInstance(cm.warning, RuntimeWarning)
1608 self.assertEqual(cm.warning.args[0], "foox")
1609 self.assertIn("test_case.py", cm.filename)
1610 self.assertEqual(cm.lineno, _runtime_warn_lineno + 1)
1611 # Failure when no warning is triggered
1612 with self.assertRaises(self.failureException):
1613 with self.assertWarnsRegex(RuntimeWarning, "o+"):
1614 pass
1615 # Custom message
1616 with self.assertRaisesRegex(self.failureException, 'foobar'):
1617 with self.assertWarnsRegex(RuntimeWarning, 'o+', msg='foobar'):
1618 pass
1619 # Invalid keyword argument
1620 with self.assertRaisesRegex(TypeError, 'foobar'):
1621 with self.assertWarnsRegex(RuntimeWarning, 'o+', foobar=42):
1622 pass
1623 # Failure when another warning is triggered
1624 with warnings.catch_warnings():
1625 # Force default filter (in case tests are run with -We)
1626 warnings.simplefilter("default", RuntimeWarning)
1627 with self.assertRaises(self.failureException):
1628 with self.assertWarnsRegex(DeprecationWarning, "o+"):
1629 _runtime_warn("foox")
1630 # Failure when message doesn't match
1631 with self.assertRaises(self.failureException):
1632 with self.assertWarnsRegex(RuntimeWarning, "o+"):
1633 _runtime_warn("barz")
1634 # A little trickier: we ask RuntimeWarnings to be raised, and then
1635 # check for some of them. It is implementation-defined whether
1636 # non-matching RuntimeWarnings are simply re-raised, or produce a
1637 # failureException.
1638 with warnings.catch_warnings():
1639 warnings.simplefilter("error", RuntimeWarning)
1640 with self.assertRaises((RuntimeWarning, self.failureException)):
1641 with self.assertWarnsRegex(RuntimeWarning, "o+"):
1642 _runtime_warn("barz")
1643
1644 def testAssertWarnsRegexNoExceptionType(self):
1645 with self.assertRaises(TypeError):
1646 self.assertWarnsRegex()
1647 with self.assertRaises(TypeError):
1648 self.assertWarnsRegex(UserWarning)
1649 with self.assertRaises(TypeError):
1650 self.assertWarnsRegex(1, 'expect')
1651 with self.assertRaises(TypeError):
1652 self.assertWarnsRegex(object, 'expect')
1653 with self.assertRaises(TypeError):
1654 self.assertWarnsRegex((UserWarning, 1), 'expect')
1655 with self.assertRaises(TypeError):
1656 self.assertWarnsRegex((UserWarning, object), 'expect')
1657 with self.assertRaises(TypeError):
1658 self.assertWarnsRegex((UserWarning, Exception), 'expect')
1659
1660 @contextlib.contextmanager
1661 def assertNoStderr(self):
1662 with captured_stderr() as buf:
1663 yield
1664 self.assertEqual(buf.getvalue(), "")
1665
1666 def assertLogRecords(self, records, matches):
1667 self.assertEqual(len(records), len(matches))
1668 for rec, match in zip(records, matches):
1669 self.assertIsInstance(rec, logging.LogRecord)
1670 for k, v in match.items():
1671 self.assertEqual(getattr(rec, k), v)
1672
1673 def testAssertLogsDefaults(self):
1674 # defaults: root logger, level INFO
1675 with self.assertNoStderr():
1676 with self.assertLogs() as cm:
1677 log_foo.info("1")
1678 log_foobar.debug("2")
1679 self.assertEqual(cm.output, ["INFO:foo:1"])
1680 self.assertLogRecords(cm.records, [{'name': 'foo'}])
1681
1682 def testAssertLogsTwoMatchingMessages(self):
1683 # Same, but with two matching log messages
1684 with self.assertNoStderr():
1685 with self.assertLogs() as cm:
1686 log_foo.info("1")
1687 log_foobar.debug("2")
1688 log_quux.warning("3")
1689 self.assertEqual(cm.output, ["INFO:foo:1", "WARNING:quux:3"])
1690 self.assertLogRecords(cm.records,
1691 [{'name': 'foo'}, {'name': 'quux'}])
1692
1693 def checkAssertLogsPerLevel(self, level):
1694 # Check level filtering
1695 with self.assertNoStderr():
1696 with self.assertLogs(level=level) as cm:
1697 log_foo.warning("1")
1698 log_foobar.error("2")
1699 log_quux.critical("3")
1700 self.assertEqual(cm.output, ["ERROR:foo.bar:2", "CRITICAL:quux:3"])
1701 self.assertLogRecords(cm.records,
1702 [{'name': 'foo.bar'}, {'name': 'quux'}])
1703
1704 def testAssertLogsPerLevel(self):
1705 self.checkAssertLogsPerLevel(logging.ERROR)
1706 self.checkAssertLogsPerLevel('ERROR')
1707
1708 def checkAssertLogsPerLogger(self, logger):
1709 # Check per-logger filtering
1710 with self.assertNoStderr():
1711 with self.assertLogs(level='DEBUG') as outer_cm:
1712 with self.assertLogs(logger, level='DEBUG') as cm:
1713 log_foo.info("1")
1714 log_foobar.debug("2")
1715 log_quux.warning("3")
1716 self.assertEqual(cm.output, ["INFO:foo:1", "DEBUG:foo.bar:2"])
1717 self.assertLogRecords(cm.records,
1718 [{'name': 'foo'}, {'name': 'foo.bar'}])
1719 # The outer catchall caught the quux log
1720 self.assertEqual(outer_cm.output, ["WARNING:quux:3"])
1721
1722 def testAssertLogsPerLogger(self):
1723 self.checkAssertLogsPerLogger(logging.getLogger('foo'))
1724 self.checkAssertLogsPerLogger('foo')
1725
1726 def testAssertLogsFailureNoLogs(self):
1727 # Failure due to no logs
1728 with self.assertNoStderr():
1729 with self.assertRaises(self.failureException):
1730 with self.assertLogs():
1731 pass
1732
1733 def testAssertLogsFailureLevelTooHigh(self):
1734 # Failure due to level too high
1735 with self.assertNoStderr():
1736 with self.assertRaises(self.failureException):
1737 with self.assertLogs(level='WARNING'):
1738 log_foo.info("1")
1739
1740 def testAssertLogsFailureLevelTooHigh_FilterInRootLogger(self):
1741 # Failure due to level too high - message propagated to root
1742 with self.assertNoStderr():
1743 oldLevel = log_foo.level
1744 log_foo.setLevel(logging.INFO)
1745 try:
1746 with self.assertRaises(self.failureException):
1747 with self.assertLogs(level='WARNING'):
1748 log_foo.info("1")
1749 finally:
1750 log_foo.setLevel(oldLevel)
1751
1752 def testAssertLogsFailureMismatchingLogger(self):
1753 # Failure due to mismatching logger (and the logged message is
1754 # passed through)
1755 with self.assertLogs('quux', level='ERROR'):
1756 with self.assertRaises(self.failureException):
1757 with self.assertLogs('foo'):
1758 log_quux.error("1")
1759
1760 def testAssertLogsUnexpectedException(self):
1761 # Check unexpected exception will go through.
1762 with self.assertRaises(ZeroDivisionError):
1763 with self.assertLogs():
1764 raise ZeroDivisionError("Unexpected")
1765
1766 def testAssertNoLogsDefault(self):
1767 with self.assertRaises(self.failureException) as cm:
1768 with self.assertNoLogs():
1769 log_foo.info("1")
1770 log_foobar.debug("2")
1771 self.assertEqual(
1772 str(cm.exception),
1773 "Unexpected logs found: ['INFO:foo:1']",
1774 )
1775
1776 def testAssertNoLogsFailureFoundLogs(self):
1777 with self.assertRaises(self.failureException) as cm:
1778 with self.assertNoLogs():
1779 log_quux.error("1")
1780 log_foo.error("foo")
1781
1782 self.assertEqual(
1783 str(cm.exception),
1784 "Unexpected logs found: ['ERROR:quux:1', 'ERROR:foo:foo']",
1785 )
1786
1787 def testAssertNoLogsPerLogger(self):
1788 with self.assertNoStderr():
1789 with self.assertLogs(log_quux):
1790 with self.assertNoLogs(logger=log_foo):
1791 log_quux.error("1")
1792
1793 def testAssertNoLogsFailurePerLogger(self):
1794 # Failure due to unexpected logs for the given logger or its
1795 # children.
1796 with self.assertRaises(self.failureException) as cm:
1797 with self.assertLogs(log_quux):
1798 with self.assertNoLogs(logger=log_foo):
1799 log_quux.error("1")
1800 log_foobar.info("2")
1801 self.assertEqual(
1802 str(cm.exception),
1803 "Unexpected logs found: ['INFO:foo.bar:2']",
1804 )
1805
1806 def testAssertNoLogsPerLevel(self):
1807 # Check per-level filtering
1808 with self.assertNoStderr():
1809 with self.assertNoLogs(level="ERROR"):
1810 log_foo.info("foo")
1811 log_quux.debug("1")
1812
1813 def testAssertNoLogsFailurePerLevel(self):
1814 # Failure due to unexpected logs at the specified level.
1815 with self.assertRaises(self.failureException) as cm:
1816 with self.assertNoLogs(level="DEBUG"):
1817 log_foo.debug("foo")
1818 log_quux.debug("1")
1819 self.assertEqual(
1820 str(cm.exception),
1821 "Unexpected logs found: ['DEBUG:foo:foo', 'DEBUG:quux:1']",
1822 )
1823
1824 def testAssertNoLogsUnexpectedException(self):
1825 # Check unexpected exception will go through.
1826 with self.assertRaises(ZeroDivisionError):
1827 with self.assertNoLogs():
1828 raise ZeroDivisionError("Unexpected")
1829
1830 def testAssertNoLogsYieldsNone(self):
1831 with self.assertNoLogs() as value:
1832 pass
1833 self.assertIsNone(value)
1834
1835 def testDeprecatedFailMethods(self):
1836 """Test that the deprecated fail* methods get removed in 3.12"""
1837 deprecated_names = [
1838 'failIfEqual', 'failUnlessEqual', 'failUnlessAlmostEqual',
1839 'failIfAlmostEqual', 'failUnless', 'failUnlessRaises', 'failIf',
1840 'assertNotEquals', 'assertEquals', 'assertAlmostEquals',
1841 'assertNotAlmostEquals', 'assert_', 'assertDictContainsSubset',
1842 'assertRaisesRegexp', 'assertRegexpMatches'
1843 ]
1844 for deprecated_name in deprecated_names:
1845 with self.assertRaises(AttributeError):
1846 getattr(self, deprecated_name)
1847
1848 def testDeepcopy(self):
1849 # Issue: 5660
1850 class ESC[4;38;5;81mTestableTest(ESC[4;38;5;149munittestESC[4;38;5;149m.ESC[4;38;5;149mTestCase):
1851 def testNothing(self):
1852 pass
1853
1854 test = TestableTest('testNothing')
1855
1856 # This shouldn't blow up
1857 deepcopy(test)
1858
1859 def testPickle(self):
1860 # Issue 10326
1861
1862 # Can't use TestCase classes defined in Test class as
1863 # pickle does not work with inner classes
1864 test = unittest.TestCase('run')
1865 for protocol in range(pickle.HIGHEST_PROTOCOL + 1):
1866
1867 # blew up prior to fix
1868 pickled_test = pickle.dumps(test, protocol=protocol)
1869 unpickled_test = pickle.loads(pickled_test)
1870 self.assertEqual(test, unpickled_test)
1871
1872 # exercise the TestCase instance in a way that will invoke
1873 # the type equality lookup mechanism
1874 unpickled_test.assertEqual(set(), set())
1875
1876 def testKeyboardInterrupt(self):
1877 def _raise(self=None):
1878 raise KeyboardInterrupt
1879 def nothing(self):
1880 pass
1881
1882 class ESC[4;38;5;81mTest1(ESC[4;38;5;149munittestESC[4;38;5;149m.ESC[4;38;5;149mTestCase):
1883 test_something = _raise
1884
1885 class ESC[4;38;5;81mTest2(ESC[4;38;5;149munittestESC[4;38;5;149m.ESC[4;38;5;149mTestCase):
1886 setUp = _raise
1887 test_something = nothing
1888
1889 class ESC[4;38;5;81mTest3(ESC[4;38;5;149munittestESC[4;38;5;149m.ESC[4;38;5;149mTestCase):
1890 test_something = nothing
1891 tearDown = _raise
1892
1893 class ESC[4;38;5;81mTest4(ESC[4;38;5;149munittestESC[4;38;5;149m.ESC[4;38;5;149mTestCase):
1894 def test_something(self):
1895 self.addCleanup(_raise)
1896
1897 for klass in (Test1, Test2, Test3, Test4):
1898 with self.assertRaises(KeyboardInterrupt):
1899 klass('test_something').run()
1900
1901 def testSkippingEverywhere(self):
1902 def _skip(self=None):
1903 raise unittest.SkipTest('some reason')
1904 def nothing(self):
1905 pass
1906
1907 class ESC[4;38;5;81mTest1(ESC[4;38;5;149munittestESC[4;38;5;149m.ESC[4;38;5;149mTestCase):
1908 test_something = _skip
1909
1910 class ESC[4;38;5;81mTest2(ESC[4;38;5;149munittestESC[4;38;5;149m.ESC[4;38;5;149mTestCase):
1911 setUp = _skip
1912 test_something = nothing
1913
1914 class ESC[4;38;5;81mTest3(ESC[4;38;5;149munittestESC[4;38;5;149m.ESC[4;38;5;149mTestCase):
1915 test_something = nothing
1916 tearDown = _skip
1917
1918 class ESC[4;38;5;81mTest4(ESC[4;38;5;149munittestESC[4;38;5;149m.ESC[4;38;5;149mTestCase):
1919 def test_something(self):
1920 self.addCleanup(_skip)
1921
1922 for klass in (Test1, Test2, Test3, Test4):
1923 result = unittest.TestResult()
1924 klass('test_something').run(result)
1925 self.assertEqual(len(result.skipped), 1)
1926 self.assertEqual(result.testsRun, 1)
1927
1928 def testSystemExit(self):
1929 def _raise(self=None):
1930 raise SystemExit
1931 def nothing(self):
1932 pass
1933
1934 class ESC[4;38;5;81mTest1(ESC[4;38;5;149munittestESC[4;38;5;149m.ESC[4;38;5;149mTestCase):
1935 test_something = _raise
1936
1937 class ESC[4;38;5;81mTest2(ESC[4;38;5;149munittestESC[4;38;5;149m.ESC[4;38;5;149mTestCase):
1938 setUp = _raise
1939 test_something = nothing
1940
1941 class ESC[4;38;5;81mTest3(ESC[4;38;5;149munittestESC[4;38;5;149m.ESC[4;38;5;149mTestCase):
1942 test_something = nothing
1943 tearDown = _raise
1944
1945 class ESC[4;38;5;81mTest4(ESC[4;38;5;149munittestESC[4;38;5;149m.ESC[4;38;5;149mTestCase):
1946 def test_something(self):
1947 self.addCleanup(_raise)
1948
1949 for klass in (Test1, Test2, Test3, Test4):
1950 result = unittest.TestResult()
1951 klass('test_something').run(result)
1952 self.assertEqual(len(result.errors), 1)
1953 self.assertEqual(result.testsRun, 1)
1954
1955 @support.cpython_only
1956 def testNoCycles(self):
1957 case = unittest.TestCase()
1958 wr = weakref.ref(case)
1959 with support.disable_gc():
1960 del case
1961 self.assertFalse(wr())
1962
1963 def test_no_exception_leak(self):
1964 # Issue #19880: TestCase.run() should not keep a reference
1965 # to the exception
1966 class ESC[4;38;5;81mMyException(ESC[4;38;5;149mException):
1967 ninstance = 0
1968
1969 def __init__(self):
1970 MyException.ninstance += 1
1971 Exception.__init__(self)
1972
1973 def __del__(self):
1974 MyException.ninstance -= 1
1975
1976 class ESC[4;38;5;81mTestCase(ESC[4;38;5;149munittestESC[4;38;5;149m.ESC[4;38;5;149mTestCase):
1977 def test1(self):
1978 raise MyException()
1979
1980 @unittest.expectedFailure
1981 def test2(self):
1982 raise MyException()
1983
1984 for method_name in ('test1', 'test2'):
1985 testcase = TestCase(method_name)
1986 testcase.run()
1987 gc_collect() # For PyPy or other GCs.
1988 self.assertEqual(MyException.ninstance, 0)
1989
1990
1991 if __name__ == "__main__":
1992 unittest.main()
Browse
Usage
Versions