1 import sys 2 import types 3 4 5 import unittest 6 7 8 class Test_TestLoader(unittest.TestCase): 9 10 ### Tests for TestLoader.loadTestsFromTestCase 11 ################################################################ 12 13 # "Return a suite of all tests cases contained in the TestCase-derived 14 # class testCaseClass" 15 def test_loadTestsFromTestCase(self): 16 class Foo(unittest.TestCase): 17 def test_1(self): pass 18 def test_2(self): pass 19 def foo_bar(self): pass 20 21 tests = unittest.TestSuite([Foo('test_1'), Foo('test_2')]) 22 23 loader = unittest.TestLoader() 24 self.assertEqual(loader.loadTestsFromTestCase(Foo), tests) 25 26 # "Return a suite of all tests cases contained in the TestCase-derived 27 # class testCaseClass" 28 # 29 # Make sure it does the right thing even if no tests were found 30 def test_loadTestsFromTestCase__no_matches(self): 31 class Foo(unittest.TestCase): 32 def foo_bar(self): pass 33 34 empty_suite = unittest.TestSuite() 35 36 loader = unittest.TestLoader() 37 self.assertEqual(loader.loadTestsFromTestCase(Foo), empty_suite) 38 39 # "Return a suite of all tests cases contained in the TestCase-derived 40 # class testCaseClass" 41 # 42 # What happens if loadTestsFromTestCase() is given an object 43 # that isn't a subclass of TestCase? Specifically, what happens 44 # if testCaseClass is a subclass of TestSuite? 45 # 46 # This is checked for specifically in the code, so we better add a 47 # test for it. 48 def test_loadTestsFromTestCase__TestSuite_subclass(self): 49 class NotATestCase(unittest.TestSuite): 50 pass 51 52 loader = unittest.TestLoader() 53 try: 54 loader.loadTestsFromTestCase(NotATestCase) 55 except TypeError: 56 pass 57 else: 58 self.fail('Should raise TypeError') 59 60 # "Return a suite of all tests cases contained in the TestCase-derived 61 # class testCaseClass" 62 # 63 # Make sure loadTestsFromTestCase() picks up the default test method 64 # name (as specified by TestCase), even though the method name does 65 # not match the default TestLoader.testMethodPrefix string 66 def test_loadTestsFromTestCase__default_method_name(self): 67 class Foo(unittest.TestCase): 68 def runTest(self): 69 pass 70 71 loader = unittest.TestLoader() 72 # This has to be false for the test to succeed 73 self.assertFalse('runTest'.startswith(loader.testMethodPrefix)) 74 75 suite = loader.loadTestsFromTestCase(Foo) 76 self.assertIsInstance(suite, loader.suiteClass) 77 self.assertEqual(list(suite), [Foo('runTest')]) 78 79 ################################################################ 80 ### /Tests for TestLoader.loadTestsFromTestCase 81 82 ### Tests for TestLoader.loadTestsFromModule 83 ################################################################ 84 85 # "This method searches `module` for classes derived from TestCase" 86 def test_loadTestsFromModule__TestCase_subclass(self): 87 m = types.ModuleType('m') 88 class MyTestCase(unittest.TestCase): 89 def test(self): 90 pass 91 m.testcase_1 = MyTestCase 92 93 loader = unittest.TestLoader() 94 suite = loader.loadTestsFromModule(m) 95 self.assertIsInstance(suite, loader.suiteClass) 96 97 expected = [loader.suiteClass([MyTestCase('test')])] 98 self.assertEqual(list(suite), expected) 99 100 # "This method searches `module` for classes derived from TestCase" 101 # 102 # What happens if no tests are found (no TestCase instances)? 103 def test_loadTestsFromModule__no_TestCase_instances(self): 104 m = types.ModuleType('m') 105 106 loader = unittest.TestLoader() 107 suite = loader.loadTestsFromModule(m) 108 self.assertIsInstance(suite, loader.suiteClass) 109 self.assertEqual(list(suite), []) 110 111 # "This method searches `module` for classes derived from TestCase" 112 # 113 # What happens if no tests are found (TestCases instances, but no tests)? 114 def test_loadTestsFromModule__no_TestCase_tests(self): 115 m = types.ModuleType('m') 116 class MyTestCase(unittest.TestCase): 117 pass 118 m.testcase_1 = MyTestCase 119 120 loader = unittest.TestLoader() 121 suite = loader.loadTestsFromModule(m) 122 self.assertIsInstance(suite, loader.suiteClass) 123 124 self.assertEqual(list(suite), [loader.suiteClass()]) 125 126 # "This method searches `module` for classes derived from TestCase"s 127 # 128 # What happens if loadTestsFromModule() is given something other 129 # than a module? 130 # 131 # XXX Currently, it succeeds anyway. This flexibility 132 # should either be documented or loadTestsFromModule() should 133 # raise a TypeError 134 # 135 # XXX Certain people are using this behaviour. We'll add a test for it 136 def test_loadTestsFromModule__not_a_module(self): 137 class MyTestCase(unittest.TestCase): 138 def test(self): 139 pass 140 141 class NotAModule(object): 142 test_2 = MyTestCase 143 144 loader = unittest.TestLoader() 145 suite = loader.loadTestsFromModule(NotAModule) 146 147 reference = [unittest.TestSuite([MyTestCase('test')])] 148 self.assertEqual(list(suite), reference) 149 150 151 # Check that loadTestsFromModule honors (or not) a module 152 # with a load_tests function. 153 def test_loadTestsFromModule__load_tests(self): 154 m = types.ModuleType('m') 155 class MyTestCase(unittest.TestCase): 156 def test(self): 157 pass 158 m.testcase_1 = MyTestCase 159 160 load_tests_args = [] 161 def load_tests(loader, tests, pattern): 162 self.assertIsInstance(tests, unittest.TestSuite) 163 load_tests_args.extend((loader, tests, pattern)) 164 return tests 165 m.load_tests = load_tests 166 167 loader = unittest.TestLoader() 168 suite = loader.loadTestsFromModule(m) 169 self.assertIsInstance(suite, unittest.TestSuite) 170 self.assertEqual(load_tests_args, [loader, suite, None]) 171 172 load_tests_args = [] 173 suite = loader.loadTestsFromModule(m, use_load_tests=False) 174 self.assertEqual(load_tests_args, []) 175 176 def test_loadTestsFromModule__faulty_load_tests(self): 177 m = types.ModuleType('m') 178 179 def load_tests(loader, tests, pattern): 180 raise TypeError('some failure') 181 m.load_tests = load_tests 182 183 loader = unittest.TestLoader() 184 suite = loader.loadTestsFromModule(m) 185 self.assertIsInstance(suite, unittest.TestSuite) 186 self.assertEqual(suite.countTestCases(), 1) 187 test = list(suite)[0] 188 189 self.assertRaisesRegexp(TypeError, "some failure", test.m) 190 191 ################################################################ 192 ### /Tests for TestLoader.loadTestsFromModule() 193 194 ### Tests for TestLoader.loadTestsFromName() 195 ################################################################ 196 197 # "The specifier name is a ``dotted name'' that may resolve either to 198 # a module, a test case class, a TestSuite instance, a test method 199 # within a test case class, or a callable object which returns a 200 # TestCase or TestSuite instance." 201 # 202 # Is ValueError raised in response to an empty name? 203 def test_loadTestsFromName__empty_name(self): 204 loader = unittest.TestLoader() 205 206 try: 207 loader.loadTestsFromName('') 208 except ValueError, e: 209 self.assertEqual(str(e), "Empty module name") 210 else: 211 self.fail("TestLoader.loadTestsFromName failed to raise ValueError") 212 213 # "The specifier name is a ``dotted name'' that may resolve either to 214 # a module, a test case class, a TestSuite instance, a test method 215 # within a test case class, or a callable object which returns a 216 # TestCase or TestSuite instance." 217 # 218 # What happens when the name contains invalid characters? 219 def test_loadTestsFromName__malformed_name(self): 220 loader = unittest.TestLoader() 221 222 # XXX Should this raise ValueError or ImportError? 223 try: 224 loader.loadTestsFromName('abc () //') 225 except ValueError: 226 pass 227 except ImportError: 228 pass 229 else: 230 self.fail("TestLoader.loadTestsFromName failed to raise ValueError") 231 232 # "The specifier name is a ``dotted name'' that may resolve ... to a 233 # module" 234 # 235 # What happens when a module by that name can't be found? 236 def test_loadTestsFromName__unknown_module_name(self): 237 loader = unittest.TestLoader() 238 239 try: 240 loader.loadTestsFromName('sdasfasfasdf') 241 except ImportError, e: 242 self.assertEqual(str(e), "No module named sdasfasfasdf") 243 else: 244 self.fail("TestLoader.loadTestsFromName failed to raise ImportError") 245 246 # "The specifier name is a ``dotted name'' that may resolve either to 247 # a module, a test case class, a TestSuite instance, a test method 248 # within a test case class, or a callable object which returns a 249 # TestCase or TestSuite instance." 250 # 251 # What happens when the module is found, but the attribute can't? 252 def test_loadTestsFromName__unknown_attr_name(self): 253 loader = unittest.TestLoader() 254 255 try: 256 loader.loadTestsFromName('unittest.sdasfasfasdf') 257 except AttributeError, e: 258 self.assertEqual(str(e), "'module' object has no attribute 'sdasfasfasdf'") 259 else: 260 self.fail("TestLoader.loadTestsFromName failed to raise AttributeError") 261 262 # "The specifier name is a ``dotted name'' that may resolve either to 263 # a module, a test case class, a TestSuite instance, a test method 264 # within a test case class, or a callable object which returns a 265 # TestCase or TestSuite instance." 266 # 267 # What happens when we provide the module, but the attribute can't be 268 # found? 269 def test_loadTestsFromName__relative_unknown_name(self): 270 loader = unittest.TestLoader() 271 272 try: 273 loader.loadTestsFromName('sdasfasfasdf', unittest) 274 except AttributeError, e: 275 self.assertEqual(str(e), "'module' object has no attribute 'sdasfasfasdf'") 276 else: 277 self.fail("TestLoader.loadTestsFromName failed to raise AttributeError") 278 279 # "The specifier name is a ``dotted name'' that may resolve either to 280 # a module, a test case class, a TestSuite instance, a test method 281 # within a test case class, or a callable object which returns a 282 # TestCase or TestSuite instance." 283 # ... 284 # "The method optionally resolves name relative to the given module" 285 # 286 # Does loadTestsFromName raise ValueError when passed an empty 287 # name relative to a provided module? 288 # 289 # XXX Should probably raise a ValueError instead of an AttributeError 290 def test_loadTestsFromName__relative_empty_name(self): 291 loader = unittest.TestLoader() 292 293 try: 294 loader.loadTestsFromName('', unittest) 295 except AttributeError: 296 pass 297 else: 298 self.fail("Failed to raise AttributeError") 299 300 # "The specifier name is a ``dotted name'' that may resolve either to 301 # a module, a test case class, a TestSuite instance, a test method 302 # within a test case class, or a callable object which returns a 303 # TestCase or TestSuite instance." 304 # ... 305 # "The method optionally resolves name relative to the given module" 306 # 307 # What happens when an impossible name is given, relative to the provided 308 # `module`? 309 def test_loadTestsFromName__relative_malformed_name(self): 310 loader = unittest.TestLoader() 311 312 # XXX Should this raise AttributeError or ValueError? 313 try: 314 loader.loadTestsFromName('abc () //', unittest) 315 except ValueError: 316 pass 317 except AttributeError: 318 pass 319 else: 320 self.fail("TestLoader.loadTestsFromName failed to raise ValueError") 321 322 # "The method optionally resolves name relative to the given module" 323 # 324 # Does loadTestsFromName raise TypeError when the `module` argument 325 # isn't a module object? 326 # 327 # XXX Accepts the not-a-module object, ignoring the object's type 328 # This should raise an exception or the method name should be changed 329 # 330 # XXX Some people are relying on this, so keep it for now 331 def test_loadTestsFromName__relative_not_a_module(self): 332 class MyTestCase(unittest.TestCase): 333 def test(self): 334 pass 335 336 class NotAModule(object): 337 test_2 = MyTestCase 338 339 loader = unittest.TestLoader() 340 suite = loader.loadTestsFromName('test_2', NotAModule) 341 342 reference = [MyTestCase('test')] 343 self.assertEqual(list(suite), reference) 344 345 # "The specifier name is a ``dotted name'' that may resolve either to 346 # a module, a test case class, a TestSuite instance, a test method 347 # within a test case class, or a callable object which returns a 348 # TestCase or TestSuite instance." 349 # 350 # Does it raise an exception if the name resolves to an invalid 351 # object? 352 def test_loadTestsFromName__relative_bad_object(self): 353 m = types.ModuleType('m') 354 m.testcase_1 = object() 355 356 loader = unittest.TestLoader() 357 try: 358 loader.loadTestsFromName('testcase_1', m) 359 except TypeError: 360 pass 361 else: 362 self.fail("Should have raised TypeError") 363 364 # "The specifier name is a ``dotted name'' that may 365 # resolve either to ... a test case class" 366 def test_loadTestsFromName__relative_TestCase_subclass(self): 367 m = types.ModuleType('m') 368 class MyTestCase(unittest.TestCase): 369 def test(self): 370 pass 371 m.testcase_1 = MyTestCase 372 373 loader = unittest.TestLoader() 374 suite = loader.loadTestsFromName('testcase_1', m) 375 self.assertIsInstance(suite, loader.suiteClass) 376 self.assertEqual(list(suite), [MyTestCase('test')]) 377 378 # "The specifier name is a ``dotted name'' that may resolve either to 379 # a module, a test case class, a TestSuite instance, a test method 380 # within a test case class, or a callable object which returns a 381 # TestCase or TestSuite instance." 382 def test_loadTestsFromName__relative_TestSuite(self): 383 m = types.ModuleType('m') 384 class MyTestCase(unittest.TestCase): 385 def test(self): 386 pass 387 m.testsuite = unittest.TestSuite([MyTestCase('test')]) 388 389 loader = unittest.TestLoader() 390 suite = loader.loadTestsFromName('testsuite', m) 391 self.assertIsInstance(suite, loader.suiteClass) 392 393 self.assertEqual(list(suite), [MyTestCase('test')]) 394 395 # "The specifier name is a ``dotted name'' that may resolve ... to 396 # ... a test method within a test case class" 397 def test_loadTestsFromName__relative_testmethod(self): 398 m = types.ModuleType('m') 399 class MyTestCase(unittest.TestCase): 400 def test(self): 401 pass 402 m.testcase_1 = MyTestCase 403 404 loader = unittest.TestLoader() 405 suite = loader.loadTestsFromName('testcase_1.test', m) 406 self.assertIsInstance(suite, loader.suiteClass) 407 408 self.assertEqual(list(suite), [MyTestCase('test')]) 409 410 # "The specifier name is a ``dotted name'' that may resolve either to 411 # a module, a test case class, a TestSuite instance, a test method 412 # within a test case class, or a callable object which returns a 413 # TestCase or TestSuite instance." 414 # 415 # Does loadTestsFromName() raise the proper exception when trying to 416 # resolve "a test method within a test case class" that doesn't exist 417 # for the given name (relative to a provided module)? 418 def test_loadTestsFromName__relative_invalid_testmethod(self): 419 m = types.ModuleType('m') 420 class MyTestCase(unittest.TestCase): 421 def test(self): 422 pass 423 m.testcase_1 = MyTestCase 424 425 loader = unittest.TestLoader() 426 try: 427 loader.loadTestsFromName('testcase_1.testfoo', m) 428 except AttributeError, e: 429 self.assertEqual(str(e), "type object 'MyTestCase' has no attribute 'testfoo'") 430 else: 431 self.fail("Failed to raise AttributeError") 432 433 # "The specifier name is a ``dotted name'' that may resolve ... to 434 # ... a callable object which returns a ... TestSuite instance" 435 def test_loadTestsFromName__callable__TestSuite(self): 436 m = types.ModuleType('m') 437 testcase_1 = unittest.FunctionTestCase(lambda: None) 438 testcase_2 = unittest.FunctionTestCase(lambda: None) 439 def return_TestSuite(): 440 return unittest.TestSuite([testcase_1, testcase_2]) 441 m.return_TestSuite = return_TestSuite 442 443 loader = unittest.TestLoader() 444 suite = loader.loadTestsFromName('return_TestSuite', m) 445 self.assertIsInstance(suite, loader.suiteClass) 446 self.assertEqual(list(suite), [testcase_1, testcase_2]) 447 448 # "The specifier name is a ``dotted name'' that may resolve ... to 449 # ... a callable object which returns a TestCase ... instance" 450 def test_loadTestsFromName__callable__TestCase_instance(self): 451 m = types.ModuleType('m') 452 testcase_1 = unittest.FunctionTestCase(lambda: None) 453 def return_TestCase(): 454 return testcase_1 455 m.return_TestCase = return_TestCase 456 457 loader = unittest.TestLoader() 458 suite = loader.loadTestsFromName('return_TestCase', m) 459 self.assertIsInstance(suite, loader.suiteClass) 460 self.assertEqual(list(suite), [testcase_1]) 461 462 # "The specifier name is a ``dotted name'' that may resolve ... to 463 # ... a callable object which returns a TestCase ... instance" 464 #***************************************************************** 465 #Override the suiteClass attribute to ensure that the suiteClass 466 #attribute is used 467 def test_loadTestsFromName__callable__TestCase_instance_ProperSuiteClass(self): 468 class SubTestSuite(unittest.TestSuite): 469 pass 470 m = types.ModuleType('m') 471 testcase_1 = unittest.FunctionTestCase(lambda: None) 472 def return_TestCase(): 473 return testcase_1 474 m.return_TestCase = return_TestCase 475 476 loader = unittest.TestLoader() 477 loader.suiteClass = SubTestSuite 478 suite = loader.loadTestsFromName('return_TestCase', m) 479 self.assertIsInstance(suite, loader.suiteClass) 480 self.assertEqual(list(suite), [testcase_1]) 481 482 # "The specifier name is a ``dotted name'' that may resolve ... to 483 # ... a test method within a test case class" 484 #***************************************************************** 485 #Override the suiteClass attribute to ensure that the suiteClass 486 #attribute is used 487 def test_loadTestsFromName__relative_testmethod_ProperSuiteClass(self): 488 class SubTestSuite(unittest.TestSuite): 489 pass 490 m = types.ModuleType('m') 491 class MyTestCase(unittest.TestCase): 492 def test(self): 493 pass 494 m.testcase_1 = MyTestCase 495 496 loader = unittest.TestLoader() 497 loader.suiteClass=SubTestSuite 498 suite = loader.loadTestsFromName('testcase_1.test', m) 499 self.assertIsInstance(suite, loader.suiteClass) 500 501 self.assertEqual(list(suite), [MyTestCase('test')]) 502 503 # "The specifier name is a ``dotted name'' that may resolve ... to 504 # ... a callable object which returns a TestCase or TestSuite instance" 505 # 506 # What happens if the callable returns something else? 507 def test_loadTestsFromName__callable__wrong_type(self): 508 m = types.ModuleType('m') 509 def return_wrong(): 510 return 6 511 m.return_wrong = return_wrong 512 513 loader = unittest.TestLoader() 514 try: 515 loader.loadTestsFromName('return_wrong', m) 516 except TypeError: 517 pass 518 else: 519 self.fail("TestLoader.loadTestsFromName failed to raise TypeError") 520 521 # "The specifier can refer to modules and packages which have not been 522 # imported; they will be imported as a side-effect" 523 def test_loadTestsFromName__module_not_loaded(self): 524 # We're going to try to load this module as a side-effect, so it 525 # better not be loaded before we try. 526 # 527 module_name = 'unittest.test.dummy' 528 sys.modules.pop(module_name, None) 529 530 loader = unittest.TestLoader() 531 try: 532 suite = loader.loadTestsFromName(module_name) 533 534 self.assertIsInstance(suite, loader.suiteClass) 535 self.assertEqual(list(suite), []) 536 537 # module should now be loaded, thanks to loadTestsFromName() 538 self.assertIn(module_name, sys.modules) 539 finally: 540 if module_name in sys.modules: 541 del sys.modules[module_name] 542 543 ################################################################ 544 ### Tests for TestLoader.loadTestsFromName() 545 546 ### Tests for TestLoader.loadTestsFromNames() 547 ################################################################ 548 549 # "Similar to loadTestsFromName(), but takes a sequence of names rather 550 # than a single name." 551 # 552 # What happens if that sequence of names is empty? 553 def test_loadTestsFromNames__empty_name_list(self): 554 loader = unittest.TestLoader() 555 556 suite = loader.loadTestsFromNames([]) 557 self.assertIsInstance(suite, loader.suiteClass) 558 self.assertEqual(list(suite), []) 559 560 # "Similar to loadTestsFromName(), but takes a sequence of names rather 561 # than a single name." 562 # ... 563 # "The method optionally resolves name relative to the given module" 564 # 565 # What happens if that sequence of names is empty? 566 # 567 # XXX Should this raise a ValueError or just return an empty TestSuite? 568 def test_loadTestsFromNames__relative_empty_name_list(self): 569 loader = unittest.TestLoader() 570 571 suite = loader.loadTestsFromNames([], unittest) 572 self.assertIsInstance(suite, loader.suiteClass) 573 self.assertEqual(list(suite), []) 574 575 # "The specifier name is a ``dotted name'' that may resolve either to 576 # a module, a test case class, a TestSuite instance, a test method 577 # within a test case class, or a callable object which returns a 578 # TestCase or TestSuite instance." 579 # 580 # Is ValueError raised in response to an empty name? 581 def test_loadTestsFromNames__empty_name(self): 582 loader = unittest.TestLoader() 583 584 try: 585 loader.loadTestsFromNames(['']) 586 except ValueError, e: 587 self.assertEqual(str(e), "Empty module name") 588 else: 589 self.fail("TestLoader.loadTestsFromNames failed to raise ValueError") 590 591 # "The specifier name is a ``dotted name'' that may resolve either to 592 # a module, a test case class, a TestSuite instance, a test method 593 # within a test case class, or a callable object which returns a 594 # TestCase or TestSuite instance." 595 # 596 # What happens when presented with an impossible module name? 597 def test_loadTestsFromNames__malformed_name(self): 598 loader = unittest.TestLoader() 599 600 # XXX Should this raise ValueError or ImportError? 601 try: 602 loader.loadTestsFromNames(['abc () //']) 603 except ValueError: 604 pass 605 except ImportError: 606 pass 607 else: 608 self.fail("TestLoader.loadTestsFromNames failed to raise ValueError") 609 610 # "The specifier name is a ``dotted name'' that may resolve either to 611 # a module, a test case class, a TestSuite instance, a test method 612 # within a test case class, or a callable object which returns a 613 # TestCase or TestSuite instance." 614 # 615 # What happens when no module can be found for the given name? 616 def test_loadTestsFromNames__unknown_module_name(self): 617 loader = unittest.TestLoader() 618 619 try: 620 loader.loadTestsFromNames(['sdasfasfasdf']) 621 except ImportError, e: 622 self.assertEqual(str(e), "No module named sdasfasfasdf") 623 else: 624 self.fail("TestLoader.loadTestsFromNames failed to raise ImportError") 625 626 # "The specifier name is a ``dotted name'' that may resolve either to 627 # a module, a test case class, a TestSuite instance, a test method 628 # within a test case class, or a callable object which returns a 629 # TestCase or TestSuite instance." 630 # 631 # What happens when the module can be found, but not the attribute? 632 def test_loadTestsFromNames__unknown_attr_name(self): 633 loader = unittest.TestLoader() 634 635 try: 636 loader.loadTestsFromNames(['unittest.sdasfasfasdf', 'unittest']) 637 except AttributeError, e: 638 self.assertEqual(str(e), "'module' object has no attribute 'sdasfasfasdf'") 639 else: 640 self.fail("TestLoader.loadTestsFromNames failed to raise AttributeError") 641 642 # "The specifier name is a ``dotted name'' that may resolve either to 643 # a module, a test case class, a TestSuite instance, a test method 644 # within a test case class, or a callable object which returns a 645 # TestCase or TestSuite instance." 646 # ... 647 # "The method optionally resolves name relative to the given module" 648 # 649 # What happens when given an unknown attribute on a specified `module` 650 # argument? 651 def test_loadTestsFromNames__unknown_name_relative_1(self): 652 loader = unittest.TestLoader() 653 654 try: 655 loader.loadTestsFromNames(['sdasfasfasdf'], unittest) 656 except AttributeError, e: 657 self.assertEqual(str(e), "'module' object has no attribute 'sdasfasfasdf'") 658 else: 659 self.fail("TestLoader.loadTestsFromName failed to raise AttributeError") 660 661 # "The specifier name is a ``dotted name'' that may resolve either to 662 # a module, a test case class, a TestSuite instance, a test method 663 # within a test case class, or a callable object which returns a 664 # TestCase or TestSuite instance." 665 # ... 666 # "The method optionally resolves name relative to the given module" 667 # 668 # Do unknown attributes (relative to a provided module) still raise an 669 # exception even in the presence of valid attribute names? 670 def test_loadTestsFromNames__unknown_name_relative_2(self): 671 loader = unittest.TestLoader() 672 673 try: 674 loader.loadTestsFromNames(['TestCase', 'sdasfasfasdf'], unittest) 675 except AttributeError, e: 676 self.assertEqual(str(e), "'module' object has no attribute 'sdasfasfasdf'") 677 else: 678 self.fail("TestLoader.loadTestsFromName failed to raise AttributeError") 679 680 # "The specifier name is a ``dotted name'' that may resolve either to 681 # a module, a test case class, a TestSuite instance, a test method 682 # within a test case class, or a callable object which returns a 683 # TestCase or TestSuite instance." 684 # ... 685 # "The method optionally resolves name relative to the given module" 686 # 687 # What happens when faced with the empty string? 688 # 689 # XXX This currently raises AttributeError, though ValueError is probably 690 # more appropriate 691 def test_loadTestsFromNames__relative_empty_name(self): 692 loader = unittest.TestLoader() 693 694 try: 695 loader.loadTestsFromNames([''], unittest) 696 except AttributeError: 697 pass 698 else: 699 self.fail("Failed to raise ValueError") 700 701 # "The specifier name is a ``dotted name'' that may resolve either to 702 # a module, a test case class, a TestSuite instance, a test method 703 # within a test case class, or a callable object which returns a 704 # TestCase or TestSuite instance." 705 # ... 706 # "The method optionally resolves name relative to the given module" 707 # 708 # What happens when presented with an impossible attribute name? 709 def test_loadTestsFromNames__relative_malformed_name(self): 710 loader = unittest.TestLoader() 711 712 # XXX Should this raise AttributeError or ValueError? 713 try: 714 loader.loadTestsFromNames(['abc () //'], unittest) 715 except AttributeError: 716 pass 717 except ValueError: 718 pass 719 else: 720 self.fail("TestLoader.loadTestsFromNames failed to raise ValueError") 721 722 # "The method optionally resolves name relative to the given module" 723 # 724 # Does loadTestsFromNames() make sure the provided `module` is in fact 725 # a module? 726 # 727 # XXX This validation is currently not done. This flexibility should 728 # either be documented or a TypeError should be raised. 729 def test_loadTestsFromNames__relative_not_a_module(self): 730 class MyTestCase(unittest.TestCase): 731 def test(self): 732 pass 733 734 class NotAModule(object): 735 test_2 = MyTestCase 736 737 loader = unittest.TestLoader() 738 suite = loader.loadTestsFromNames(['test_2'], NotAModule) 739 740 reference = [unittest.TestSuite([MyTestCase('test')])] 741 self.assertEqual(list(suite), reference) 742 743 # "The specifier name is a ``dotted name'' that may resolve either to 744 # a module, a test case class, a TestSuite instance, a test method 745 # within a test case class, or a callable object which returns a 746 # TestCase or TestSuite instance." 747 # 748 # Does it raise an exception if the name resolves to an invalid 749 # object? 750 def test_loadTestsFromNames__relative_bad_object(self): 751 m = types.ModuleType('m') 752 m.testcase_1 = object() 753 754 loader = unittest.TestLoader() 755 try: 756 loader.loadTestsFromNames(['testcase_1'], m) 757 except TypeError: 758 pass 759 else: 760 self.fail("Should have raised TypeError") 761 762 # "The specifier name is a ``dotted name'' that may resolve ... to 763 # ... a test case class" 764 def test_loadTestsFromNames__relative_TestCase_subclass(self): 765 m = types.ModuleType('m') 766 class MyTestCase(unittest.TestCase): 767 def test(self): 768 pass 769 m.testcase_1 = MyTestCase 770 771 loader = unittest.TestLoader() 772 suite = loader.loadTestsFromNames(['testcase_1'], m) 773 self.assertIsInstance(suite, loader.suiteClass) 774 775 expected = loader.suiteClass([MyTestCase('test')]) 776 self.assertEqual(list(suite), [expected]) 777 778 # "The specifier name is a ``dotted name'' that may resolve ... to 779 # ... a TestSuite instance" 780 def test_loadTestsFromNames__relative_TestSuite(self): 781 m = types.ModuleType('m') 782 class MyTestCase(unittest.TestCase): 783 def test(self): 784 pass 785 m.testsuite = unittest.TestSuite([MyTestCase('test')]) 786 787 loader = unittest.TestLoader() 788 suite = loader.loadTestsFromNames(['testsuite'], m) 789 self.assertIsInstance(suite, loader.suiteClass) 790 791 self.assertEqual(list(suite), [m.testsuite]) 792 793 # "The specifier name is a ``dotted name'' that may resolve ... to ... a 794 # test method within a test case class" 795 def test_loadTestsFromNames__relative_testmethod(self): 796 m = types.ModuleType('m') 797 class MyTestCase(unittest.TestCase): 798 def test(self): 799 pass 800 m.testcase_1 = MyTestCase 801 802 loader = unittest.TestLoader() 803 suite = loader.loadTestsFromNames(['testcase_1.test'], m) 804 self.assertIsInstance(suite, loader.suiteClass) 805 806 ref_suite = unittest.TestSuite([MyTestCase('test')]) 807 self.assertEqual(list(suite), [ref_suite]) 808 809 # "The specifier name is a ``dotted name'' that may resolve ... to ... a 810 # test method within a test case class" 811 # 812 # Does the method gracefully handle names that initially look like they 813 # resolve to "a test method within a test case class" but don't? 814 def test_loadTestsFromNames__relative_invalid_testmethod(self): 815 m = types.ModuleType('m') 816 class MyTestCase(unittest.TestCase): 817 def test(self): 818 pass 819 m.testcase_1 = MyTestCase 820 821 loader = unittest.TestLoader() 822 try: 823 loader.loadTestsFromNames(['testcase_1.testfoo'], m) 824 except AttributeError, e: 825 self.assertEqual(str(e), "type object 'MyTestCase' has no attribute 'testfoo'") 826 else: 827 self.fail("Failed to raise AttributeError") 828 829 # "The specifier name is a ``dotted name'' that may resolve ... to 830 # ... a callable object which returns a ... TestSuite instance" 831 def test_loadTestsFromNames__callable__TestSuite(self): 832 m = types.ModuleType('m') 833 testcase_1 = unittest.FunctionTestCase(lambda: None) 834 testcase_2 = unittest.FunctionTestCase(lambda: None) 835 def return_TestSuite(): 836 return unittest.TestSuite([testcase_1, testcase_2]) 837 m.return_TestSuite = return_TestSuite 838 839 loader = unittest.TestLoader() 840 suite = loader.loadTestsFromNames(['return_TestSuite'], m) 841 self.assertIsInstance(suite, loader.suiteClass) 842 843 expected = unittest.TestSuite([testcase_1, testcase_2]) 844 self.assertEqual(list(suite), [expected]) 845 846 # "The specifier name is a ``dotted name'' that may resolve ... to 847 # ... a callable object which returns a TestCase ... instance" 848 def test_loadTestsFromNames__callable__TestCase_instance(self): 849 m = types.ModuleType('m') 850 testcase_1 = unittest.FunctionTestCase(lambda: None) 851 def return_TestCase(): 852 return testcase_1 853 m.return_TestCase = return_TestCase 854 855 loader = unittest.TestLoader() 856 suite = loader.loadTestsFromNames(['return_TestCase'], m) 857 self.assertIsInstance(suite, loader.suiteClass) 858 859 ref_suite = unittest.TestSuite([testcase_1]) 860 self.assertEqual(list(suite), [ref_suite]) 861 862 # "The specifier name is a ``dotted name'' that may resolve ... to 863 # ... a callable object which returns a TestCase or TestSuite instance" 864 # 865 # Are staticmethods handled correctly? 866 def test_loadTestsFromNames__callable__call_staticmethod(self): 867 m = types.ModuleType('m') 868 class Test1(unittest.TestCase): 869 def test(self): 870 pass 871 872 testcase_1 = Test1('test') 873 class Foo(unittest.TestCase): 874 @staticmethod 875 def foo(): 876 return testcase_1 877 m.Foo = Foo 878 879 loader = unittest.TestLoader() 880 suite = loader.loadTestsFromNames(['Foo.foo'], m) 881 self.assertIsInstance(suite, loader.suiteClass) 882 883 ref_suite = unittest.TestSuite([testcase_1]) 884 self.assertEqual(list(suite), [ref_suite]) 885 886 # "The specifier name is a ``dotted name'' that may resolve ... to 887 # ... a callable object which returns a TestCase or TestSuite instance" 888 # 889 # What happens when the callable returns something else? 890 def test_loadTestsFromNames__callable__wrong_type(self): 891 m = types.ModuleType('m') 892 def return_wrong(): 893 return 6 894 m.return_wrong = return_wrong 895 896 loader = unittest.TestLoader() 897 try: 898 loader.loadTestsFromNames(['return_wrong'], m) 899 except TypeError: 900 pass 901 else: 902 self.fail("TestLoader.loadTestsFromNames failed to raise TypeError") 903 904 # "The specifier can refer to modules and packages which have not been 905 # imported; they will be imported as a side-effect" 906 def test_loadTestsFromNames__module_not_loaded(self): 907 # We're going to try to load this module as a side-effect, so it 908 # better not be loaded before we try. 909 # 910 module_name = 'unittest.test.dummy' 911 sys.modules.pop(module_name, None) 912 913 loader = unittest.TestLoader() 914 try: 915 suite = loader.loadTestsFromNames([module_name]) 916 917 self.assertIsInstance(suite, loader.suiteClass) 918 self.assertEqual(list(suite), [unittest.TestSuite()]) 919 920 # module should now be loaded, thanks to loadTestsFromName() 921 self.assertIn(module_name, sys.modules) 922 finally: 923 if module_name in sys.modules: 924 del sys.modules[module_name] 925 926 ################################################################ 927 ### /Tests for TestLoader.loadTestsFromNames() 928 929 ### Tests for TestLoader.getTestCaseNames() 930 ################################################################ 931 932 # "Return a sorted sequence of method names found within testCaseClass" 933 # 934 # Test.foobar is defined to make sure getTestCaseNames() respects 935 # loader.testMethodPrefix 936 def test_getTestCaseNames(self): 937 class Test(unittest.TestCase): 938 def test_1(self): pass 939 def test_2(self): pass 940 def foobar(self): pass 941 942 loader = unittest.TestLoader() 943 944 self.assertEqual(loader.getTestCaseNames(Test), ['test_1', 'test_2']) 945 946 # "Return a sorted sequence of method names found within testCaseClass" 947 # 948 # Does getTestCaseNames() behave appropriately if no tests are found? 949 def test_getTestCaseNames__no_tests(self): 950 class Test(unittest.TestCase): 951 def foobar(self): pass 952 953 loader = unittest.TestLoader() 954 955 self.assertEqual(loader.getTestCaseNames(Test), []) 956 957 # "Return a sorted sequence of method names found within testCaseClass" 958 # 959 # Are not-TestCases handled gracefully? 960 # 961 # XXX This should raise a TypeError, not return a list 962 # 963 # XXX It's too late in the 2.5 release cycle to fix this, but it should 964 # probably be revisited for 2.6 965 def test_getTestCaseNames__not_a_TestCase(self): 966 class BadCase(int): 967 def test_foo(self): 968 pass 969 970 loader = unittest.TestLoader() 971 names = loader.getTestCaseNames(BadCase) 972 973 self.assertEqual(names, ['test_foo']) 974 975 # "Return a sorted sequence of method names found within testCaseClass" 976 # 977 # Make sure inherited names are handled. 978 # 979 # TestP.foobar is defined to make sure getTestCaseNames() respects 980 # loader.testMethodPrefix 981 def test_getTestCaseNames__inheritance(self): 982 class TestP(unittest.TestCase): 983 def test_1(self): pass 984 def test_2(self): pass 985 def foobar(self): pass 986 987 class TestC(TestP): 988 def test_1(self): pass 989 def test_3(self): pass 990 991 loader = unittest.TestLoader() 992 993 names = ['test_1', 'test_2', 'test_3'] 994 self.assertEqual(loader.getTestCaseNames(TestC), names) 995 996 ################################################################ 997 ### /Tests for TestLoader.getTestCaseNames() 998 999 ### Tests for TestLoader.testMethodPrefix 1000 ################################################################ 1001 1002 # "String giving the prefix of method names which will be interpreted as 1003 # test methods" 1004 # 1005 # Implicit in the documentation is that testMethodPrefix is respected by 1006 # all loadTestsFrom* methods. 1007 def test_testMethodPrefix__loadTestsFromTestCase(self): 1008 class Foo(unittest.TestCase): 1009 def test_1(self): pass 1010 def test_2(self): pass 1011 def foo_bar(self): pass 1012 1013 tests_1 = unittest.TestSuite([Foo('foo_bar')]) 1014 tests_2 = unittest.TestSuite([Foo('test_1'), Foo('test_2')]) 1015 1016 loader = unittest.TestLoader() 1017 loader.testMethodPrefix = 'foo' 1018 self.assertEqual(loader.loadTestsFromTestCase(Foo), tests_1) 1019 1020 loader.testMethodPrefix = 'test' 1021 self.assertEqual(loader.loadTestsFromTestCase(Foo), tests_2) 1022 1023 # "String giving the prefix of method names which will be interpreted as 1024 # test methods" 1025 # 1026 # Implicit in the documentation is that testMethodPrefix is respected by 1027 # all loadTestsFrom* methods. 1028 def test_testMethodPrefix__loadTestsFromModule(self): 1029 m = types.ModuleType('m') 1030 class Foo(unittest.TestCase): 1031 def test_1(self): pass 1032 def test_2(self): pass 1033 def foo_bar(self): pass 1034 m.Foo = Foo 1035 1036 tests_1 = [unittest.TestSuite([Foo('foo_bar')])] 1037 tests_2 = [unittest.TestSuite([Foo('test_1'), Foo('test_2')])] 1038 1039 loader = unittest.TestLoader() 1040 loader.testMethodPrefix = 'foo' 1041 self.assertEqual(list(loader.loadTestsFromModule(m)), tests_1) 1042 1043 loader.testMethodPrefix = 'test' 1044 self.assertEqual(list(loader.loadTestsFromModule(m)), tests_2) 1045 1046 # "String giving the prefix of method names which will be interpreted as 1047 # test methods" 1048 # 1049 # Implicit in the documentation is that testMethodPrefix is respected by 1050 # all loadTestsFrom* methods. 1051 def test_testMethodPrefix__loadTestsFromName(self): 1052 m = types.ModuleType('m') 1053 class Foo(unittest.TestCase): 1054 def test_1(self): pass 1055 def test_2(self): pass 1056 def foo_bar(self): pass 1057 m.Foo = Foo 1058 1059 tests_1 = unittest.TestSuite([Foo('foo_bar')]) 1060 tests_2 = unittest.TestSuite([Foo('test_1'), Foo('test_2')]) 1061 1062 loader = unittest.TestLoader() 1063 loader.testMethodPrefix = 'foo' 1064 self.assertEqual(loader.loadTestsFromName('Foo', m), tests_1) 1065 1066 loader.testMethodPrefix = 'test' 1067 self.assertEqual(loader.loadTestsFromName('Foo', m), tests_2) 1068 1069 # "String giving the prefix of method names which will be interpreted as 1070 # test methods" 1071 # 1072 # Implicit in the documentation is that testMethodPrefix is respected by 1073 # all loadTestsFrom* methods. 1074 def test_testMethodPrefix__loadTestsFromNames(self): 1075 m = types.ModuleType('m') 1076 class Foo(unittest.TestCase): 1077 def test_1(self): pass 1078 def test_2(self): pass 1079 def foo_bar(self): pass 1080 m.Foo = Foo 1081 1082 tests_1 = unittest.TestSuite([unittest.TestSuite([Foo('foo_bar')])]) 1083 tests_2 = unittest.TestSuite([Foo('test_1'), Foo('test_2')]) 1084 tests_2 = unittest.TestSuite([tests_2]) 1085 1086 loader = unittest.TestLoader() 1087 loader.testMethodPrefix = 'foo' 1088 self.assertEqual(loader.loadTestsFromNames(['Foo'], m), tests_1) 1089 1090 loader.testMethodPrefix = 'test' 1091 self.assertEqual(loader.loadTestsFromNames(['Foo'], m), tests_2) 1092 1093 # "The default value is 'test'" 1094 def test_testMethodPrefix__default_value(self): 1095 loader = unittest.TestLoader() 1096 self.assertTrue(loader.testMethodPrefix == 'test') 1097 1098 ################################################################ 1099 ### /Tests for TestLoader.testMethodPrefix 1100 1101 ### Tests for TestLoader.sortTestMethodsUsing 1102 ################################################################ 1103 1104 # "Function to be used to compare method names when sorting them in 1105 # getTestCaseNames() and all the loadTestsFromX() methods" 1106 def test_sortTestMethodsUsing__loadTestsFromTestCase(self): 1107 def reversed_cmp(x, y): 1108 return -cmp(x, y) 1109 1110 class Foo(unittest.TestCase): 1111 def test_1(self): pass 1112 def test_2(self): pass 1113 1114 loader = unittest.TestLoader() 1115 loader.sortTestMethodsUsing = reversed_cmp 1116 1117 tests = loader.suiteClass([Foo('test_2'), Foo('test_1')]) 1118 self.assertEqual(loader.loadTestsFromTestCase(Foo), tests) 1119 1120 # "Function to be used to compare method names when sorting them in 1121 # getTestCaseNames() and all the loadTestsFromX() methods" 1122 def test_sortTestMethodsUsing__loadTestsFromModule(self): 1123 def reversed_cmp(x, y): 1124 return -cmp(x, y) 1125 1126 m = types.ModuleType('m') 1127 class Foo(unittest.TestCase): 1128 def test_1(self): pass 1129 def test_2(self): pass 1130 m.Foo = Foo 1131 1132 loader = unittest.TestLoader() 1133 loader.sortTestMethodsUsing = reversed_cmp 1134 1135 tests = [loader.suiteClass([Foo('test_2'), Foo('test_1')])] 1136 self.assertEqual(list(loader.loadTestsFromModule(m)), tests) 1137 1138 # "Function to be used to compare method names when sorting them in 1139 # getTestCaseNames() and all the loadTestsFromX() methods" 1140 def test_sortTestMethodsUsing__loadTestsFromName(self): 1141 def reversed_cmp(x, y): 1142 return -cmp(x, y) 1143 1144 m = types.ModuleType('m') 1145 class Foo(unittest.TestCase): 1146 def test_1(self): pass 1147 def test_2(self): pass 1148 m.Foo = Foo 1149 1150 loader = unittest.TestLoader() 1151 loader.sortTestMethodsUsing = reversed_cmp 1152 1153 tests = loader.suiteClass([Foo('test_2'), Foo('test_1')]) 1154 self.assertEqual(loader.loadTestsFromName('Foo', m), tests) 1155 1156 # "Function to be used to compare method names when sorting them in 1157 # getTestCaseNames() and all the loadTestsFromX() methods" 1158 def test_sortTestMethodsUsing__loadTestsFromNames(self): 1159 def reversed_cmp(x, y): 1160 return -cmp(x, y) 1161 1162 m = types.ModuleType('m') 1163 class Foo(unittest.TestCase): 1164 def test_1(self): pass 1165 def test_2(self): pass 1166 m.Foo = Foo 1167 1168 loader = unittest.TestLoader() 1169 loader.sortTestMethodsUsing = reversed_cmp 1170 1171 tests = [loader.suiteClass([Foo('test_2'), Foo('test_1')])] 1172 self.assertEqual(list(loader.loadTestsFromNames(['Foo'], m)), tests) 1173 1174 # "Function to be used to compare method names when sorting them in 1175 # getTestCaseNames()" 1176 # 1177 # Does it actually affect getTestCaseNames()? 1178 def test_sortTestMethodsUsing__getTestCaseNames(self): 1179 def reversed_cmp(x, y): 1180 return -cmp(x, y) 1181 1182 class Foo(unittest.TestCase): 1183 def test_1(self): pass 1184 def test_2(self): pass 1185 1186 loader = unittest.TestLoader() 1187 loader.sortTestMethodsUsing = reversed_cmp 1188 1189 test_names = ['test_2', 'test_1'] 1190 self.assertEqual(loader.getTestCaseNames(Foo), test_names) 1191 1192 # "The default value is the built-in cmp() function" 1193 def test_sortTestMethodsUsing__default_value(self): 1194 loader = unittest.TestLoader() 1195 self.assertTrue(loader.sortTestMethodsUsing is cmp) 1196 1197 # "it can be set to None to disable the sort." 1198 # 1199 # XXX How is this different from reassigning cmp? Are the tests returned 1200 # in a random order or something? This behaviour should die 1201 def test_sortTestMethodsUsing__None(self): 1202 class Foo(unittest.TestCase): 1203 def test_1(self): pass 1204 def test_2(self): pass 1205 1206 loader = unittest.TestLoader() 1207 loader.sortTestMethodsUsing = None 1208 1209 test_names = ['test_2', 'test_1'] 1210 self.assertEqual(set(loader.getTestCaseNames(Foo)), set(test_names)) 1211 1212 ################################################################ 1213 ### /Tests for TestLoader.sortTestMethodsUsing 1214 1215 ### Tests for TestLoader.suiteClass 1216 ################################################################ 1217 1218 # "Callable object that constructs a test suite from a list of tests." 1219 def test_suiteClass__loadTestsFromTestCase(self): 1220 class Foo(unittest.TestCase): 1221 def test_1(self): pass 1222 def test_2(self): pass 1223 def foo_bar(self): pass 1224 1225 tests = [Foo('test_1'), Foo('test_2')] 1226 1227 loader = unittest.TestLoader() 1228 loader.suiteClass = list 1229 self.assertEqual(loader.loadTestsFromTestCase(Foo), tests) 1230 1231 # It is implicit in the documentation for TestLoader.suiteClass that 1232 # all TestLoader.loadTestsFrom* methods respect it. Let's make sure 1233 def test_suiteClass__loadTestsFromModule(self): 1234 m = types.ModuleType('m') 1235 class Foo(unittest.TestCase): 1236 def test_1(self): pass 1237 def test_2(self): pass 1238 def foo_bar(self): pass 1239 m.Foo = Foo 1240 1241 tests = [[Foo('test_1'), Foo('test_2')]] 1242 1243 loader = unittest.TestLoader() 1244 loader.suiteClass = list 1245 self.assertEqual(loader.loadTestsFromModule(m), tests) 1246 1247 # It is implicit in the documentation for TestLoader.suiteClass that 1248 # all TestLoader.loadTestsFrom* methods respect it. Let's make sure 1249 def test_suiteClass__loadTestsFromName(self): 1250 m = types.ModuleType('m') 1251 class Foo(unittest.TestCase): 1252 def test_1(self): pass 1253 def test_2(self): pass 1254 def foo_bar(self): pass 1255 m.Foo = Foo 1256 1257 tests = [Foo('test_1'), Foo('test_2')] 1258 1259 loader = unittest.TestLoader() 1260 loader.suiteClass = list 1261 self.assertEqual(loader.loadTestsFromName('Foo', m), tests) 1262 1263 # It is implicit in the documentation for TestLoader.suiteClass that 1264 # all TestLoader.loadTestsFrom* methods respect it. Let's make sure 1265 def test_suiteClass__loadTestsFromNames(self): 1266 m = types.ModuleType('m') 1267 class Foo(unittest.TestCase): 1268 def test_1(self): pass 1269 def test_2(self): pass 1270 def foo_bar(self): pass 1271 m.Foo = Foo 1272 1273 tests = [[Foo('test_1'), Foo('test_2')]] 1274 1275 loader = unittest.TestLoader() 1276 loader.suiteClass = list 1277 self.assertEqual(loader.loadTestsFromNames(['Foo'], m), tests) 1278 1279 # "The default value is the TestSuite class" 1280 def test_suiteClass__default_value(self): 1281 loader = unittest.TestLoader() 1282 self.assertIs(loader.suiteClass, unittest.TestSuite) 1283 1284 # Make sure the dotted name resolution works even if the actual 1285 # function doesn't have the same name as is used to find it. 1286 def test_loadTestsFromName__function_with_different_name_than_method(self): 1287 # lambdas have the name '<lambda>'. 1288 m = types.ModuleType('m') 1289 class MyTestCase(unittest.TestCase): 1290 test = lambda: 1 1291 m.testcase_1 = MyTestCase 1292 1293 loader = unittest.TestLoader() 1294 suite = loader.loadTestsFromNames(['testcase_1.test'], m) 1295 self.assertIsInstance(suite, loader.suiteClass) 1296 1297 ref_suite = unittest.TestSuite([MyTestCase('test')]) 1298 self.assertEqual(list(suite), [ref_suite]) 1299 1300 if __name__ == '__main__': 1301 unittest.main() 1302
