1 import difflib 2 import pprint 3 import re 4 import sys 5 6 from copy import deepcopy 7 from test import test_support 8 9 import unittest 10 11 from .support import ( 12 TestEquality, TestHashing, LoggingResult, ResultWithNoStartTestRunStopTestRun 13 ) 14 15 16 class Test(object): 17 "Keep these TestCase classes out of the main namespace" 18 19 class Foo(unittest.TestCase): 20 def runTest(self): pass 21 def test1(self): pass 22 23 class Bar(Foo): 24 def test2(self): pass 25 26 class LoggingTestCase(unittest.TestCase): 27 """A test case which logs its calls.""" 28 29 def __init__(self, events): 30 super(Test.LoggingTestCase, self).__init__('test') 31 self.events = events 32 33 def setUp(self): 34 self.events.append('setUp') 35 36 def test(self): 37 self.events.append('test') 38 39 def tearDown(self): 40 self.events.append('tearDown') 41 42 43 class Test_TestCase(unittest.TestCase, TestEquality, TestHashing): 44 45 ### Set up attributes used by inherited tests 46 ################################################################ 47 48 # Used by TestHashing.test_hash and TestEquality.test_eq 49 eq_pairs = [(Test.Foo('test1'), Test.Foo('test1'))] 50 51 # Used by TestEquality.test_ne 52 ne_pairs = [(Test.Foo('test1'), Test.Foo('runTest')) 53 ,(Test.Foo('test1'), Test.Bar('test1')) 54 ,(Test.Foo('test1'), Test.Bar('test2'))] 55 56 ################################################################ 57 ### /Set up attributes used by inherited tests 58 59 60 # "class TestCase([methodName])" 61 # ... 62 # "Each instance of TestCase will run a single test method: the 63 # method named methodName." 64 # ... 65 # "methodName defaults to "runTest"." 66 # 67 # Make sure it really is optional, and that it defaults to the proper 68 # thing. 69 def test_init__no_test_name(self): 70 class Test(unittest.TestCase): 71 def runTest(self): raise TypeError() 72 def test(self): pass 73 74 self.assertEqual(Test().id()[-13:], '.Test.runTest') 75 76 # "class TestCase([methodName])" 77 # ... 78 # "Each instance of TestCase will run a single test method: the 79 # method named methodName." 80 def test_init__test_name__valid(self): 81 class Test(unittest.TestCase): 82 def runTest(self): raise TypeError() 83 def test(self): pass 84 85 self.assertEqual(Test('test').id()[-10:], '.Test.test') 86 87 # "class TestCase([methodName])" 88 # ... 89 # "Each instance of TestCase will run a single test method: the 90 # method named methodName." 91 def test_init__test_name__invalid(self): 92 class Test(unittest.TestCase): 93 def runTest(self): raise TypeError() 94 def test(self): pass 95 96 try: 97 Test('testfoo') 98 except ValueError: 99 pass 100 else: 101 self.fail("Failed to raise ValueError") 102 103 # "Return the number of tests represented by the this test object. For 104 # TestCase instances, this will always be 1" 105 def test_countTestCases(self): 106 class Foo(unittest.TestCase): 107 def test(self): pass 108 109 self.assertEqual(Foo('test').countTestCases(), 1) 110 111 # "Return the default type of test result object to be used to run this 112 # test. For TestCase instances, this will always be 113 # unittest.TestResult; subclasses of TestCase should 114 # override this as necessary." 115 def test_defaultTestResult(self): 116 class Foo(unittest.TestCase): 117 def runTest(self): 118 pass 119 120 result = Foo().defaultTestResult() 121 self.assertEqual(type(result), unittest.TestResult) 122 123 # "When a setUp() method is defined, the test runner will run that method 124 # prior to each test. Likewise, if a tearDown() method is defined, the 125 # test runner will invoke that method after each test. In the example, 126 # setUp() was used to create a fresh sequence for each test." 127 # 128 # Make sure the proper call order is maintained, even if setUp() raises 129 # an exception. 130 def test_run_call_order__error_in_setUp(self): 131 events = [] 132 result = LoggingResult(events) 133 134 class Foo(Test.LoggingTestCase): 135 def setUp(self): 136 super(Foo, self).setUp() 137 raise RuntimeError('raised by Foo.setUp') 138 139 Foo(events).run(result) 140 expected = ['startTest', 'setUp', 'addError', 'stopTest'] 141 self.assertEqual(events, expected) 142 143 # "With a temporary result stopTestRun is called when setUp errors. 144 def test_run_call_order__error_in_setUp_default_result(self): 145 events = [] 146 147 class Foo(Test.LoggingTestCase): 148 def defaultTestResult(self): 149 return LoggingResult(self.events) 150 151 def setUp(self): 152 super(Foo, self).setUp() 153 raise RuntimeError('raised by Foo.setUp') 154 155 Foo(events).run() 156 expected = ['startTestRun', 'startTest', 'setUp', 'addError', 157 'stopTest', 'stopTestRun'] 158 self.assertEqual(events, expected) 159 160 # "When a setUp() method is defined, the test runner will run that method 161 # prior to each test. Likewise, if a tearDown() method is defined, the 162 # test runner will invoke that method after each test. In the example, 163 # setUp() was used to create a fresh sequence for each test." 164 # 165 # Make sure the proper call order is maintained, even if the test raises 166 # an error (as opposed to a failure). 167 def test_run_call_order__error_in_test(self): 168 events = [] 169 result = LoggingResult(events) 170 171 class Foo(Test.LoggingTestCase): 172 def test(self): 173 super(Foo, self).test() 174 raise RuntimeError('raised by Foo.test') 175 176 expected = ['startTest', 'setUp', 'test', 'addError', 'tearDown', 177 'stopTest'] 178 Foo(events).run(result) 179 self.assertEqual(events, expected) 180 181 # "With a default result, an error in the test still results in stopTestRun 182 # being called." 183 def test_run_call_order__error_in_test_default_result(self): 184 events = [] 185 186 class Foo(Test.LoggingTestCase): 187 def defaultTestResult(self): 188 return LoggingResult(self.events) 189 190 def test(self): 191 super(Foo, self).test() 192 raise RuntimeError('raised by Foo.test') 193 194 expected = ['startTestRun', 'startTest', 'setUp', 'test', 'addError', 195 'tearDown', 'stopTest', 'stopTestRun'] 196 Foo(events).run() 197 self.assertEqual(events, expected) 198 199 # "When a setUp() method is defined, the test runner will run that method 200 # prior to each test. Likewise, if a tearDown() method is defined, the 201 # test runner will invoke that method after each test. In the example, 202 # setUp() was used to create a fresh sequence for each test." 203 # 204 # Make sure the proper call order is maintained, even if the test signals 205 # a failure (as opposed to an error). 206 def test_run_call_order__failure_in_test(self): 207 events = [] 208 result = LoggingResult(events) 209 210 class Foo(Test.LoggingTestCase): 211 def test(self): 212 super(Foo, self).test() 213 self.fail('raised by Foo.test') 214 215 expected = ['startTest', 'setUp', 'test', 'addFailure', 'tearDown', 216 'stopTest'] 217 Foo(events).run(result) 218 self.assertEqual(events, expected) 219 220 # "When a test fails with a default result stopTestRun is still called." 221 def test_run_call_order__failure_in_test_default_result(self): 222 223 class Foo(Test.LoggingTestCase): 224 def defaultTestResult(self): 225 return LoggingResult(self.events) 226 def test(self): 227 super(Foo, self).test() 228 self.fail('raised by Foo.test') 229 230 expected = ['startTestRun', 'startTest', 'setUp', 'test', 'addFailure', 231 'tearDown', 'stopTest', 'stopTestRun'] 232 events = [] 233 Foo(events).run() 234 self.assertEqual(events, expected) 235 236 # "When a setUp() method is defined, the test runner will run that method 237 # prior to each test. Likewise, if a tearDown() method is defined, the 238 # test runner will invoke that method after each test. In the example, 239 # setUp() was used to create a fresh sequence for each test." 240 # 241 # Make sure the proper call order is maintained, even if tearDown() raises 242 # an exception. 243 def test_run_call_order__error_in_tearDown(self): 244 events = [] 245 result = LoggingResult(events) 246 247 class Foo(Test.LoggingTestCase): 248 def tearDown(self): 249 super(Foo, self).tearDown() 250 raise RuntimeError('raised by Foo.tearDown') 251 252 Foo(events).run(result) 253 expected = ['startTest', 'setUp', 'test', 'tearDown', 'addError', 254 'stopTest'] 255 self.assertEqual(events, expected) 256 257 # "When tearDown errors with a default result stopTestRun is still called." 258 def test_run_call_order__error_in_tearDown_default_result(self): 259 260 class Foo(Test.LoggingTestCase): 261 def defaultTestResult(self): 262 return LoggingResult(self.events) 263 def tearDown(self): 264 super(Foo, self).tearDown() 265 raise RuntimeError('raised by Foo.tearDown') 266 267 events = [] 268 Foo(events).run() 269 expected = ['startTestRun', 'startTest', 'setUp', 'test', 'tearDown', 270 'addError', 'stopTest', 'stopTestRun'] 271 self.assertEqual(events, expected) 272 273 # "TestCase.run() still works when the defaultTestResult is a TestResult 274 # that does not support startTestRun and stopTestRun. 275 def test_run_call_order_default_result(self): 276 277 class Foo(unittest.TestCase): 278 def defaultTestResult(self): 279 return ResultWithNoStartTestRunStopTestRun() 280 def test(self): 281 pass 282 283 Foo('test').run() 284 285 # "This class attribute gives the exception raised by the test() method. 286 # If a test framework needs to use a specialized exception, possibly to 287 # carry additional information, it must subclass this exception in 288 # order to ``play fair'' with the framework. The initial value of this 289 # attribute is AssertionError" 290 def test_failureException__default(self): 291 class Foo(unittest.TestCase): 292 def test(self): 293 pass 294 295 self.assertTrue(Foo('test').failureException is AssertionError) 296 297 # "This class attribute gives the exception raised by the test() method. 298 # If a test framework needs to use a specialized exception, possibly to 299 # carry additional information, it must subclass this exception in 300 # order to ``play fair'' with the framework." 301 # 302 # Make sure TestCase.run() respects the designated failureException 303 def test_failureException__subclassing__explicit_raise(self): 304 events = [] 305 result = LoggingResult(events) 306 307 class Foo(unittest.TestCase): 308 def test(self): 309 raise RuntimeError() 310 311 failureException = RuntimeError 312 313 self.assertTrue(Foo('test').failureException is RuntimeError) 314 315 316 Foo('test').run(result) 317 expected = ['startTest', 'addFailure', 'stopTest'] 318 self.assertEqual(events, expected) 319 320 # "This class attribute gives the exception raised by the test() method. 321 # If a test framework needs to use a specialized exception, possibly to 322 # carry additional information, it must subclass this exception in 323 # order to ``play fair'' with the framework." 324 # 325 # Make sure TestCase.run() respects the designated failureException 326 def test_failureException__subclassing__implicit_raise(self): 327 events = [] 328 result = LoggingResult(events) 329 330 class Foo(unittest.TestCase): 331 def test(self): 332 self.fail("foo") 333 334 failureException = RuntimeError 335 336 self.assertTrue(Foo('test').failureException is RuntimeError) 337 338 339 Foo('test').run(result) 340 expected = ['startTest', 'addFailure', 'stopTest'] 341 self.assertEqual(events, expected) 342 343 # "The default implementation does nothing." 344 def test_setUp(self): 345 class Foo(unittest.TestCase): 346 def runTest(self): 347 pass 348 349 # ... and nothing should happen 350 Foo().setUp() 351 352 # "The default implementation does nothing." 353 def test_tearDown(self): 354 class Foo(unittest.TestCase): 355 def runTest(self): 356 pass 357 358 # ... and nothing should happen 359 Foo().tearDown() 360 361 # "Return a string identifying the specific test case." 362 # 363 # Because of the vague nature of the docs, I'm not going to lock this 364 # test down too much. Really all that can be asserted is that the id() 365 # will be a string (either 8-byte or unicode -- again, because the docs 366 # just say "string") 367 def test_id(self): 368 class Foo(unittest.TestCase): 369 def runTest(self): 370 pass 371 372 self.assertIsInstance(Foo().id(), basestring) 373 374 # "If result is omitted or None, a temporary result object is created 375 # and used, but is not made available to the caller. As TestCase owns the 376 # temporary result startTestRun and stopTestRun are called. 377 378 def test_run__uses_defaultTestResult(self): 379 events = [] 380 381 class Foo(unittest.TestCase): 382 def test(self): 383 events.append('test') 384 385 def defaultTestResult(self): 386 return LoggingResult(events) 387 388 # Make run() find a result object on its own 389 Foo('test').run() 390 391 expected = ['startTestRun', 'startTest', 'test', 'addSuccess', 392 'stopTest', 'stopTestRun'] 393 self.assertEqual(events, expected) 394 395 def testShortDescriptionWithoutDocstring(self): 396 self.assertIsNone(self.shortDescription()) 397 398 @unittest.skipIf(sys.flags.optimize >= 2, 399 "Docstrings are omitted with -O2 and above") 400 def testShortDescriptionWithOneLineDocstring(self): 401 """Tests shortDescription() for a method with a docstring.""" 402 self.assertEqual( 403 self.shortDescription(), 404 'Tests shortDescription() for a method with a docstring.') 405 406 @unittest.skipIf(sys.flags.optimize >= 2, 407 "Docstrings are omitted with -O2 and above") 408 def testShortDescriptionWithMultiLineDocstring(self): 409 """Tests shortDescription() for a method with a longer docstring. 410 411 This method ensures that only the first line of a docstring is 412 returned used in the short description, no matter how long the 413 whole thing is. 414 """ 415 self.assertEqual( 416 self.shortDescription(), 417 'Tests shortDescription() for a method with a longer ' 418 'docstring.') 419 420 def testAddTypeEqualityFunc(self): 421 class SadSnake(object): 422 """Dummy class for test_addTypeEqualityFunc.""" 423 s1, s2 = SadSnake(), SadSnake() 424 self.assertNotEqual(s1, s2) 425 def AllSnakesCreatedEqual(a, b, msg=None): 426 return type(a) is type(b) is SadSnake 427 self.addTypeEqualityFunc(SadSnake, AllSnakesCreatedEqual) 428 self.assertEqual(s1, s2) 429 # No this doesn't clean up and remove the SadSnake equality func 430 # from this TestCase instance but since its a local nothing else 431 # will ever notice that. 432 433 def testAssertIs(self): 434 thing = object() 435 self.assertIs(thing, thing) 436 self.assertRaises(self.failureException, self.assertIs, thing, object()) 437 438 def testAssertIsNot(self): 439 thing = object() 440 self.assertIsNot(thing, object()) 441 self.assertRaises(self.failureException, self.assertIsNot, thing, thing) 442 443 def testAssertIsInstance(self): 444 thing = [] 445 self.assertIsInstance(thing, list) 446 self.assertRaises(self.failureException, self.assertIsInstance, 447 thing, dict) 448 449 def testAssertNotIsInstance(self): 450 thing = [] 451 self.assertNotIsInstance(thing, dict) 452 self.assertRaises(self.failureException, self.assertNotIsInstance, 453 thing, list) 454 455 def testAssertIn(self): 456 animals = {'monkey': 'banana', 'cow': 'grass', 'seal': 'fish'} 457 458 self.assertIn('a', 'abc') 459 self.assertIn(2, [1, 2, 3]) 460 self.assertIn('monkey', animals) 461 462 self.assertNotIn('d', 'abc') 463 self.assertNotIn(0, [1, 2, 3]) 464 self.assertNotIn('otter', animals) 465 466 self.assertRaises(self.failureException, self.assertIn, 'x', 'abc') 467 self.assertRaises(self.failureException, self.assertIn, 4, [1, 2, 3]) 468 self.assertRaises(self.failureException, self.assertIn, 'elephant', 469 animals) 470 471 self.assertRaises(self.failureException, self.assertNotIn, 'c', 'abc') 472 self.assertRaises(self.failureException, self.assertNotIn, 1, [1, 2, 3]) 473 self.assertRaises(self.failureException, self.assertNotIn, 'cow', 474 animals) 475 476 def testAssertDictContainsSubset(self): 477 self.assertDictContainsSubset({}, {}) 478 self.assertDictContainsSubset({}, {'a': 1}) 479 self.assertDictContainsSubset({'a': 1}, {'a': 1}) 480 self.assertDictContainsSubset({'a': 1}, {'a': 1, 'b': 2}) 481 self.assertDictContainsSubset({'a': 1, 'b': 2}, {'a': 1, 'b': 2}) 482 483 with self.assertRaises(self.failureException): 484 self.assertDictContainsSubset({1: "one"}, {}) 485 486 with self.assertRaises(self.failureException): 487 self.assertDictContainsSubset({'a': 2}, {'a': 1}) 488 489 with self.assertRaises(self.failureException): 490 self.assertDictContainsSubset({'c': 1}, {'a': 1}) 491 492 with self.assertRaises(self.failureException): 493 self.assertDictContainsSubset({'a': 1, 'c': 1}, {'a': 1}) 494 495 with self.assertRaises(self.failureException): 496 self.assertDictContainsSubset({'a': 1, 'c': 1}, {'a': 1}) 497 498 with test_support.check_warnings(("", UnicodeWarning)): 499 one = ''.join(chr(i) for i in range(255)) 500 # this used to cause a UnicodeDecodeError constructing the failure msg 501 with self.assertRaises(self.failureException): 502 self.assertDictContainsSubset({'foo': one}, {'foo': u'\uFFFD'}) 503 504 def testAssertEqual(self): 505 equal_pairs = [ 506 ((), ()), 507 ({}, {}), 508 ([], []), 509 (set(), set()), 510 (frozenset(), frozenset())] 511 for a, b in equal_pairs: 512 # This mess of try excepts is to test the assertEqual behavior 513 # itself. 514 try: 515 self.assertEqual(a, b) 516 except self.failureException: 517 self.fail('assertEqual(%r, %r) failed' % (a, b)) 518 try: 519 self.assertEqual(a, b, msg='foo') 520 except self.failureException: 521 self.fail('assertEqual(%r, %r) with msg= failed' % (a, b)) 522 try: 523 self.assertEqual(a, b, 'foo') 524 except self.failureException: 525 self.fail('assertEqual(%r, %r) with third parameter failed' % 526 (a, b)) 527 528 unequal_pairs = [ 529 ((), []), 530 ({}, set()), 531 (set([4,1]), frozenset([4,2])), 532 (frozenset([4,5]), set([2,3])), 533 (set([3,4]), set([5,4]))] 534 for a, b in unequal_pairs: 535 self.assertRaises(self.failureException, self.assertEqual, a, b) 536 self.assertRaises(self.failureException, self.assertEqual, a, b, 537 'foo') 538 self.assertRaises(self.failureException, self.assertEqual, a, b, 539 msg='foo') 540 541 def testEquality(self): 542 self.assertListEqual([], []) 543 self.assertTupleEqual((), ()) 544 self.assertSequenceEqual([], ()) 545 546 a = [0, 'a', []] 547 b = [] 548 self.assertRaises(unittest.TestCase.failureException, 549 self.assertListEqual, a, b) 550 self.assertRaises(unittest.TestCase.failureException, 551 self.assertListEqual, tuple(a), tuple(b)) 552 self.assertRaises(unittest.TestCase.failureException, 553 self.assertSequenceEqual, a, tuple(b)) 554 555 b.extend(a) 556 self.assertListEqual(a, b) 557 self.assertTupleEqual(tuple(a), tuple(b)) 558 self.assertSequenceEqual(a, tuple(b)) 559 self.assertSequenceEqual(tuple(a), b) 560 561 self.assertRaises(self.failureException, self.assertListEqual, 562 a, tuple(b)) 563 self.assertRaises(self.failureException, self.assertTupleEqual, 564 tuple(a), b) 565 self.assertRaises(self.failureException, self.assertListEqual, None, b) 566 self.assertRaises(self.failureException, self.assertTupleEqual, None, 567 tuple(b)) 568 self.assertRaises(self.failureException, self.assertSequenceEqual, 569 None, tuple(b)) 570 self.assertRaises(self.failureException, self.assertListEqual, 1, 1) 571 self.assertRaises(self.failureException, self.assertTupleEqual, 1, 1) 572 self.assertRaises(self.failureException, self.assertSequenceEqual, 573 1, 1) 574 575 self.assertDictEqual({}, {}) 576 577 c = { 'x': 1 } 578 d = {} 579 self.assertRaises(unittest.TestCase.failureException, 580 self.assertDictEqual, c, d) 581 582 d.update(c) 583 self.assertDictEqual(c, d) 584 585 d['x'] = 0 586 self.assertRaises(unittest.TestCase.failureException, 587 self.assertDictEqual, c, d, 'These are unequal') 588 589 self.assertRaises(self.failureException, self.assertDictEqual, None, d) 590 self.assertRaises(self.failureException, self.assertDictEqual, [], d) 591 self.assertRaises(self.failureException, self.assertDictEqual, 1, 1) 592 593 def testAssertSequenceEqualMaxDiff(self): 594 self.assertEqual(self.maxDiff, 80*8) 595 seq1 = 'a' + 'x' * 80**2 596 seq2 = 'b' + 'x' * 80**2 597 diff = '\n'.join(difflib.ndiff(pprint.pformat(seq1).splitlines(), 598 pprint.pformat(seq2).splitlines())) 599 # the +1 is the leading \n added by assertSequenceEqual 600 omitted = unittest.case.DIFF_OMITTED % (len(diff) + 1,) 601 602 self.maxDiff = len(diff)//2 603 try: 604 self.assertSequenceEqual(seq1, seq2) 605 except self.failureException as e: 606 msg = e.args[0] 607 else: 608 self.fail('assertSequenceEqual did not fail.') 609 self.assertTrue(len(msg) < len(diff)) 610 self.assertIn(omitted, msg) 611 612 self.maxDiff = len(diff) * 2 613 try: 614 self.assertSequenceEqual(seq1, seq2) 615 except self.failureException as e: 616 msg = e.args[0] 617 else: 618 self.fail('assertSequenceEqual did not fail.') 619 self.assertTrue(len(msg) > len(diff)) 620 self.assertNotIn(omitted, msg) 621 622 self.maxDiff = None 623 try: 624 self.assertSequenceEqual(seq1, seq2) 625 except self.failureException as e: 626 msg = e.args[0] 627 else: 628 self.fail('assertSequenceEqual did not fail.') 629 self.assertTrue(len(msg) > len(diff)) 630 self.assertNotIn(omitted, msg) 631 632 def testTruncateMessage(self): 633 self.maxDiff = 1 634 message = self._truncateMessage('foo', 'bar') 635 omitted = unittest.case.DIFF_OMITTED % len('bar') 636 self.assertEqual(message, 'foo' + omitted) 637 638 self.maxDiff = None 639 message = self._truncateMessage('foo', 'bar') 640 self.assertEqual(message, 'foobar') 641 642 self.maxDiff = 4 643 message = self._truncateMessage('foo', 'bar') 644 self.assertEqual(message, 'foobar') 645 646 def testAssertDictEqualTruncates(self): 647 test = unittest.TestCase('assertEqual') 648 def truncate(msg, diff): 649 return 'foo' 650 test._truncateMessage = truncate 651 try: 652 test.assertDictEqual({}, {1: 0}) 653 except self.failureException as e: 654 self.assertEqual(str(e), 'foo') 655 else: 656 self.fail('assertDictEqual did not fail') 657 658 def testAssertMultiLineEqualTruncates(self): 659 test = unittest.TestCase('assertEqual') 660 def truncate(msg, diff): 661 return 'foo' 662 test._truncateMessage = truncate 663 try: 664 test.assertMultiLineEqual('foo', 'bar') 665 except self.failureException as e: 666 self.assertEqual(str(e), 'foo') 667 else: 668 self.fail('assertMultiLineEqual did not fail') 669 670 def testAssertEqual_diffThreshold(self): 671 # check threshold value 672 self.assertEqual(self._diffThreshold, 2**16) 673 # disable madDiff to get diff markers 674 self.maxDiff = None 675 676 # set a lower threshold value and add a cleanup to restore it 677 old_threshold = self._diffThreshold 678 self._diffThreshold = 2**8 679 self.addCleanup(lambda: setattr(self, '_diffThreshold', old_threshold)) 680 681 # under the threshold: diff marker (^) in error message 682 s = u'x' * (2**7) 683 with self.assertRaises(self.failureException) as cm: 684 self.assertEqual(s + 'a', s + 'b') 685 self.assertIn('^', str(cm.exception)) 686 self.assertEqual(s + 'a', s + 'a') 687 688 # over the threshold: diff not used and marker (^) not in error message 689 s = u'x' * (2**9) 690 # if the path that uses difflib is taken, _truncateMessage will be 691 # called -- replace it with explodingTruncation to verify that this 692 # doesn't happen 693 def explodingTruncation(message, diff): 694 raise SystemError('this should not be raised') 695 old_truncate = self._truncateMessage 696 self._truncateMessage = explodingTruncation 697 self.addCleanup(lambda: setattr(self, '_truncateMessage', old_truncate)) 698 699 s1, s2 = s + 'a', s + 'b' 700 with self.assertRaises(self.failureException) as cm: 701 self.assertEqual(s1, s2) 702 self.assertNotIn('^', str(cm.exception)) 703 self.assertEqual(str(cm.exception), '%r != %r' % (s1, s2)) 704 self.assertEqual(s + 'a', s + 'a') 705 706 def testAssertItemsEqual(self): 707 a = object() 708 self.assertItemsEqual([1, 2, 3], [3, 2, 1]) 709 self.assertItemsEqual(['foo', 'bar', 'baz'], ['bar', 'baz', 'foo']) 710 self.assertItemsEqual([a, a, 2, 2, 3], (a, 2, 3, a, 2)) 711 self.assertItemsEqual([1, "2", "a", "a"], ["a", "2", True, "a"]) 712 self.assertRaises(self.failureException, self.assertItemsEqual, 713 [1, 2] + [3] * 100, [1] * 100 + [2, 3]) 714 self.assertRaises(self.failureException, self.assertItemsEqual, 715 [1, "2", "a", "a"], ["a", "2", True, 1]) 716 self.assertRaises(self.failureException, self.assertItemsEqual, 717 [10], [10, 11]) 718 self.assertRaises(self.failureException, self.assertItemsEqual, 719 [10, 11], [10]) 720 self.assertRaises(self.failureException, self.assertItemsEqual, 721 [10, 11, 10], [10, 11]) 722 723 # Test that sequences of unhashable objects can be tested for sameness: 724 self.assertItemsEqual([[1, 2], [3, 4], 0], [False, [3, 4], [1, 2]]) 725 # Test that iterator of unhashable objects can be tested for sameness: 726 self.assertItemsEqual(iter([1, 2, [], 3, 4]), 727 iter([1, 2, [], 3, 4])) 728 729 # hashable types, but not orderable 730 self.assertRaises(self.failureException, self.assertItemsEqual, 731 [], [divmod, 'x', 1, 5j, 2j, frozenset()]) 732 # comparing dicts 733 self.assertItemsEqual([{'a': 1}, {'b': 2}], [{'b': 2}, {'a': 1}]) 734 # comparing heterogenous non-hashable sequences 735 self.assertItemsEqual([1, 'x', divmod, []], [divmod, [], 'x', 1]) 736 self.assertRaises(self.failureException, self.assertItemsEqual, 737 [], [divmod, [], 'x', 1, 5j, 2j, set()]) 738 self.assertRaises(self.failureException, self.assertItemsEqual, 739 [[1]], [[2]]) 740 741 # Same elements, but not same sequence length 742 self.assertRaises(self.failureException, self.assertItemsEqual, 743 [1, 1, 2], [2, 1]) 744 self.assertRaises(self.failureException, self.assertItemsEqual, 745 [1, 1, "2", "a", "a"], ["2", "2", True, "a"]) 746 self.assertRaises(self.failureException, self.assertItemsEqual, 747 [1, {'b': 2}, None, True], [{'b': 2}, True, None]) 748 749 # Same elements which don't reliably compare, in 750 # different order, see issue 10242 751 a = [{2,4}, {1,2}] 752 b = a[::-1] 753 self.assertItemsEqual(a, b) 754 755 # test utility functions supporting assertItemsEqual() 756 757 diffs = set(unittest.util._count_diff_all_purpose('aaabccd', 'abbbcce')) 758 expected = {(3,1,'a'), (1,3,'b'), (1,0,'d'), (0,1,'e')} 759 self.assertEqual(diffs, expected) 760 761 diffs = unittest.util._count_diff_all_purpose([[]], []) 762 self.assertEqual(diffs, [(1, 0, [])]) 763 764 diffs = set(unittest.util._count_diff_hashable('aaabccd', 'abbbcce')) 765 expected = {(3,1,'a'), (1,3,'b'), (1,0,'d'), (0,1,'e')} 766 self.assertEqual(diffs, expected) 767 768 def testAssertSetEqual(self): 769 set1 = set() 770 set2 = set() 771 self.assertSetEqual(set1, set2) 772 773 self.assertRaises(self.failureException, self.assertSetEqual, None, set2) 774 self.assertRaises(self.failureException, self.assertSetEqual, [], set2) 775 self.assertRaises(self.failureException, self.assertSetEqual, set1, None) 776 self.assertRaises(self.failureException, self.assertSetEqual, set1, []) 777 778 set1 = set(['a']) 779 set2 = set() 780 self.assertRaises(self.failureException, self.assertSetEqual, set1, set2) 781 782 set1 = set(['a']) 783 set2 = set(['a']) 784 self.assertSetEqual(set1, set2) 785 786 set1 = set(['a']) 787 set2 = set(['a', 'b']) 788 self.assertRaises(self.failureException, self.assertSetEqual, set1, set2) 789 790 set1 = set(['a']) 791 set2 = frozenset(['a', 'b']) 792 self.assertRaises(self.failureException, self.assertSetEqual, set1, set2) 793 794 set1 = set(['a', 'b']) 795 set2 = frozenset(['a', 'b']) 796 self.assertSetEqual(set1, set2) 797 798 set1 = set() 799 set2 = "foo" 800 self.assertRaises(self.failureException, self.assertSetEqual, set1, set2) 801 self.assertRaises(self.failureException, self.assertSetEqual, set2, set1) 802 803 # make sure any string formatting is tuple-safe 804 set1 = set([(0, 1), (2, 3)]) 805 set2 = set([(4, 5)]) 806 self.assertRaises(self.failureException, self.assertSetEqual, set1, set2) 807 808 def testInequality(self): 809 # Try ints 810 self.assertGreater(2, 1) 811 self.assertGreaterEqual(2, 1) 812 self.assertGreaterEqual(1, 1) 813 self.assertLess(1, 2) 814 self.assertLessEqual(1, 2) 815 self.assertLessEqual(1, 1) 816 self.assertRaises(self.failureException, self.assertGreater, 1, 2) 817 self.assertRaises(self.failureException, self.assertGreater, 1, 1) 818 self.assertRaises(self.failureException, self.assertGreaterEqual, 1, 2) 819 self.assertRaises(self.failureException, self.assertLess, 2, 1) 820 self.assertRaises(self.failureException, self.assertLess, 1, 1) 821 self.assertRaises(self.failureException, self.assertLessEqual, 2, 1) 822 823 # Try Floats 824 self.assertGreater(1.1, 1.0) 825 self.assertGreaterEqual(1.1, 1.0) 826 self.assertGreaterEqual(1.0, 1.0) 827 self.assertLess(1.0, 1.1) 828 self.assertLessEqual(1.0, 1.1) 829 self.assertLessEqual(1.0, 1.0) 830 self.assertRaises(self.failureException, self.assertGreater, 1.0, 1.1) 831 self.assertRaises(self.failureException, self.assertGreater, 1.0, 1.0) 832 self.assertRaises(self.failureException, self.assertGreaterEqual, 1.0, 1.1) 833 self.assertRaises(self.failureException, self.assertLess, 1.1, 1.0) 834 self.assertRaises(self.failureException, self.assertLess, 1.0, 1.0) 835 self.assertRaises(self.failureException, self.assertLessEqual, 1.1, 1.0) 836 837 # Try Strings 838 self.assertGreater('bug', 'ant') 839 self.assertGreaterEqual('bug', 'ant') 840 self.assertGreaterEqual('ant', 'ant') 841 self.assertLess('ant', 'bug') 842 self.assertLessEqual('ant', 'bug') 843 self.assertLessEqual('ant', 'ant') 844 self.assertRaises(self.failureException, self.assertGreater, 'ant', 'bug') 845 self.assertRaises(self.failureException, self.assertGreater, 'ant', 'ant') 846 self.assertRaises(self.failureException, self.assertGreaterEqual, 'ant', 'bug') 847 self.assertRaises(self.failureException, self.assertLess, 'bug', 'ant') 848 self.assertRaises(self.failureException, self.assertLess, 'ant', 'ant') 849 self.assertRaises(self.failureException, self.assertLessEqual, 'bug', 'ant') 850 851 # Try Unicode 852 self.assertGreater(u'bug', u'ant') 853 self.assertGreaterEqual(u'bug', u'ant') 854 self.assertGreaterEqual(u'ant', u'ant') 855 self.assertLess(u'ant', u'bug') 856 self.assertLessEqual(u'ant', u'bug') 857 self.assertLessEqual(u'ant', u'ant') 858 self.assertRaises(self.failureException, self.assertGreater, u'ant', u'bug') 859 self.assertRaises(self.failureException, self.assertGreater, u'ant', u'ant') 860 self.assertRaises(self.failureException, self.assertGreaterEqual, u'ant', 861 u'bug') 862 self.assertRaises(self.failureException, self.assertLess, u'bug', u'ant') 863 self.assertRaises(self.failureException, self.assertLess, u'ant', u'ant') 864 self.assertRaises(self.failureException, self.assertLessEqual, u'bug', u'ant') 865 866 # Try Mixed String/Unicode 867 self.assertGreater('bug', u'ant') 868 self.assertGreater(u'bug', 'ant') 869 self.assertGreaterEqual('bug', u'ant') 870 self.assertGreaterEqual(u'bug', 'ant') 871 self.assertGreaterEqual('ant', u'ant') 872 self.assertGreaterEqual(u'ant', 'ant') 873 self.assertLess('ant', u'bug') 874 self.assertLess(u'ant', 'bug') 875 self.assertLessEqual('ant', u'bug') 876 self.assertLessEqual(u'ant', 'bug') 877 self.assertLessEqual('ant', u'ant') 878 self.assertLessEqual(u'ant', 'ant') 879 self.assertRaises(self.failureException, self.assertGreater, 'ant', u'bug') 880 self.assertRaises(self.failureException, self.assertGreater, u'ant', 'bug') 881 self.assertRaises(self.failureException, self.assertGreater, 'ant', u'ant') 882 self.assertRaises(self.failureException, self.assertGreater, u'ant', 'ant') 883 self.assertRaises(self.failureException, self.assertGreaterEqual, 'ant', 884 u'bug') 885 self.assertRaises(self.failureException, self.assertGreaterEqual, u'ant', 886 'bug') 887 self.assertRaises(self.failureException, self.assertLess, 'bug', u'ant') 888 self.assertRaises(self.failureException, self.assertLess, u'bug', 'ant') 889 self.assertRaises(self.failureException, self.assertLess, 'ant', u'ant') 890 self.assertRaises(self.failureException, self.assertLess, u'ant', 'ant') 891 self.assertRaises(self.failureException, self.assertLessEqual, 'bug', u'ant') 892 self.assertRaises(self.failureException, self.assertLessEqual, u'bug', 'ant') 893 894 def testAssertMultiLineEqual(self): 895 sample_text = b"""\ 896 http://www.python.org/doc/2.3/lib/module-unittest.html 897 test case 898 A test case is the smallest unit of testing. [...] 899 """ 900 revised_sample_text = b"""\ 901 http://www.python.org/doc/2.4.1/lib/module-unittest.html 902 test case 903 A test case is the smallest unit of testing. [...] You may provide your 904 own implementation that does not subclass from TestCase, of course. 905 """ 906 sample_text_error = b"""\ 907 - http://www.python.org/doc/2.3/lib/module-unittest.html 908 ? ^ 909 + http://www.python.org/doc/2.4.1/lib/module-unittest.html 910 ? ^^^ 911 test case 912 - A test case is the smallest unit of testing. [...] 913 + A test case is the smallest unit of testing. [...] You may provide your 914 ? +++++++++++++++++++++ 915 + own implementation that does not subclass from TestCase, of course. 916 """ 917 self.maxDiff = None 918 for type_changer in (lambda x: x, lambda x: x.decode('utf8')): 919 try: 920 self.assertMultiLineEqual(type_changer(sample_text), 921 type_changer(revised_sample_text)) 922 except self.failureException, e: 923 # need to remove the first line of the error message 924 error = str(e).encode('utf8').split('\n', 1)[1] 925 926 # assertMultiLineEqual is hooked up as the default for 927 # unicode strings - so we can't use it for this check 928 self.assertTrue(sample_text_error == error) 929 930 def testAsertEqualSingleLine(self): 931 sample_text = u"laden swallows fly slowly" 932 revised_sample_text = u"unladen swallows fly quickly" 933 sample_text_error = """\ 934 - laden swallows fly slowly 935 ? ^^^^ 936 + unladen swallows fly quickly 937 ? ++ ^^^^^ 938 """ 939 try: 940 self.assertEqual(sample_text, revised_sample_text) 941 except self.failureException as e: 942 error = str(e).split('\n', 1)[1] 943 self.assertTrue(sample_text_error == error) 944 945 def testAssertIsNone(self): 946 self.assertIsNone(None) 947 self.assertRaises(self.failureException, self.assertIsNone, False) 948 self.assertIsNotNone('DjZoPloGears on Rails') 949 self.assertRaises(self.failureException, self.assertIsNotNone, None) 950 951 def testAssertRegexpMatches(self): 952 self.assertRegexpMatches('asdfabasdf', r'ab+') 953 self.assertRaises(self.failureException, self.assertRegexpMatches, 954 'saaas', r'aaaa') 955 956 def testAssertRaisesRegexp(self): 957 class ExceptionMock(Exception): 958 pass 959 960 def Stub(): 961 raise ExceptionMock('We expect') 962 963 self.assertRaisesRegexp(ExceptionMock, re.compile('expect$'), Stub) 964 self.assertRaisesRegexp(ExceptionMock, 'expect$', Stub) 965 self.assertRaisesRegexp(ExceptionMock, u'expect$', Stub) 966 967 def testAssertNotRaisesRegexp(self): 968 self.assertRaisesRegexp( 969 self.failureException, '^Exception not raised$', 970 self.assertRaisesRegexp, Exception, re.compile('x'), 971 lambda: None) 972 self.assertRaisesRegexp( 973 self.failureException, '^Exception not raised$', 974 self.assertRaisesRegexp, Exception, 'x', 975 lambda: None) 976 self.assertRaisesRegexp( 977 self.failureException, '^Exception not raised$', 978 self.assertRaisesRegexp, Exception, u'x', 979 lambda: None) 980 981 def testAssertRaisesRegexpMismatch(self): 982 def Stub(): 983 raise Exception('Unexpected') 984 985 self.assertRaisesRegexp( 986 self.failureException, 987 r'"\^Expected\$" does not match "Unexpected"', 988 self.assertRaisesRegexp, Exception, '^Expected$', 989 Stub) 990 self.assertRaisesRegexp( 991 self.failureException, 992 r'"\^Expected\$" does not match "Unexpected"', 993 self.assertRaisesRegexp, Exception, u'^Expected$', 994 Stub) 995 self.assertRaisesRegexp( 996 self.failureException, 997 r'"\^Expected\$" does not match "Unexpected"', 998 self.assertRaisesRegexp, Exception, 999 re.compile('^Expected$'), Stub) 1000 1001 def testAssertRaisesExcValue(self): 1002 class ExceptionMock(Exception): 1003 pass 1004 1005 def Stub(foo): 1006 raise ExceptionMock(foo) 1007 v = "particular value" 1008 1009 ctx = self.assertRaises(ExceptionMock) 1010 with ctx: 1011 Stub(v) 1012 e = ctx.exception 1013 self.assertIsInstance(e, ExceptionMock) 1014 self.assertEqual(e.args[0], v) 1015 1016 def testSynonymAssertMethodNames(self): 1017 """Test undocumented method name synonyms. 1018 1019 Please do not use these methods names in your own code. 1020 1021 This test confirms their continued existence and functionality 1022 in order to avoid breaking existing code. 1023 """ 1024 self.assertNotEquals(3, 5) 1025 self.assertEquals(3, 3) 1026 self.assertAlmostEquals(2.0, 2.0) 1027 self.assertNotAlmostEquals(3.0, 5.0) 1028 self.assert_(True) 1029 1030 def testPendingDeprecationMethodNames(self): 1031 """Test fail* methods pending deprecation, they will warn in 3.2. 1032 1033 Do not use these methods. They will go away in 3.3. 1034 """ 1035 with test_support.check_warnings(): 1036 self.failIfEqual(3, 5) 1037 self.failUnlessEqual(3, 3) 1038 self.failUnlessAlmostEqual(2.0, 2.0) 1039 self.failIfAlmostEqual(3.0, 5.0) 1040 self.failUnless(True) 1041 self.failUnlessRaises(TypeError, lambda _: 3.14 + u'spam') 1042 self.failIf(False) 1043 1044 def testDeepcopy(self): 1045 # Issue: 5660 1046 class TestableTest(unittest.TestCase): 1047 def testNothing(self): 1048 pass 1049 1050 test = TestableTest('testNothing') 1051 1052 # This shouldn't blow up 1053 deepcopy(test) 1054 1055 def testKeyboardInterrupt(self): 1056 def _raise(self=None): 1057 raise KeyboardInterrupt 1058 def nothing(self): 1059 pass 1060 1061 class Test1(unittest.TestCase): 1062 test_something = _raise 1063 1064 class Test2(unittest.TestCase): 1065 setUp = _raise 1066 test_something = nothing 1067 1068 class Test3(unittest.TestCase): 1069 test_something = nothing 1070 tearDown = _raise 1071 1072 class Test4(unittest.TestCase): 1073 def test_something(self): 1074 self.addCleanup(_raise) 1075 1076 for klass in (Test1, Test2, Test3, Test4): 1077 with self.assertRaises(KeyboardInterrupt): 1078 klass('test_something').run() 1079 1080 def testSystemExit(self): 1081 def _raise(self=None): 1082 raise SystemExit 1083 def nothing(self): 1084 pass 1085 1086 class Test1(unittest.TestCase): 1087 test_something = _raise 1088 1089 class Test2(unittest.TestCase): 1090 setUp = _raise 1091 test_something = nothing 1092 1093 class Test3(unittest.TestCase): 1094 test_something = nothing 1095 tearDown = _raise 1096 1097 class Test4(unittest.TestCase): 1098 def test_something(self): 1099 self.addCleanup(_raise) 1100 1101 for klass in (Test1, Test2, Test3, Test4): 1102 result = unittest.TestResult() 1103 klass('test_something').run(result) 1104 self.assertEqual(len(result.errors), 1) 1105 self.assertEqual(result.testsRun, 1) 1106 1107 1108 if __name__ == '__main__': 1109 unittest.main() 1110
