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