LEFT | RIGHT |
1 """Test script for unittest. | 1 """Test script for unittest. |
2 | 2 |
3 By Collin Winter <collinw at gmail.com> | 3 By Collin Winter <collinw at gmail.com> |
4 | 4 |
5 Still need testing: | 5 Still need testing: |
6 TestCase.{assert,fail}* methods (some are tested implicitly) | 6 TestCase.{assert,fail}* methods (some are tested implicitly) |
7 """ | 7 """ |
8 | 8 |
9 import re | 9 import re |
10 from test import test_support | 10 from test import test_support |
(...skipping 54 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
65 for obj_1, obj_2 in self.ne_pairs: | 65 for obj_1, obj_2 in self.ne_pairs: |
66 self.failIfEqual(obj_1, obj_2) | 66 self.failIfEqual(obj_1, obj_2) |
67 self.failIfEqual(obj_2, obj_1) | 67 self.failIfEqual(obj_2, obj_1) |
68 | 68 |
69 class TestHashing(object): | 69 class TestHashing(object): |
70 # Check for a valid __hash__ implementation | 70 # Check for a valid __hash__ implementation |
71 def test_hash(self): | 71 def test_hash(self): |
72 for obj_1, obj_2 in self.eq_pairs: | 72 for obj_1, obj_2 in self.eq_pairs: |
73 try: | 73 try: |
74 if not hash(obj_1) == hash(obj_2): | 74 if not hash(obj_1) == hash(obj_2): |
75 raise AssertionError | 75 self.fail("%r and %r do not hash equal" % (obj_1, obj_2)) |
76 except KeyboardInterrupt: | 76 except KeyboardInterrupt: |
77 raise | 77 raise |
78 except AssertionError: | |
79 self.fail("%s and %s do not hash equal" % (obj_1, obj_2)) | |
80 except Exception, e: | 78 except Exception, e: |
81 self.fail("Problem hashing %s and %s: %s" % (obj_1, obj_2, e)) | 79 self.fail("Problem hashing %r and %r: %s" % (obj_1, obj_2, e)) |
82 | 80 |
83 for obj_1, obj_2 in self.ne_pairs: | 81 for obj_1, obj_2 in self.ne_pairs: |
84 try: | 82 try: |
85 if hash(obj_1) == hash(obj_2): | 83 if hash(obj_1) == hash(obj_2): |
86 raise AssertionError | 84 self.fail("%s and %s hash equal, but shouldn't" % |
| 85 (obj_1, obj_2)) |
87 except KeyboardInterrupt: | 86 except KeyboardInterrupt: |
88 raise | 87 raise |
89 except AssertionError: | |
90 self.fail("%s and %s hash equal, but shouldn't" % (obj_1, obj_2)
) | |
91 except Exception, e: | 88 except Exception, e: |
92 self.fail("Problem hashing %s and %s: %s" % (obj_1, obj_2, e)) | 89 self.fail("Problem hashing %s and %s: %s" % (obj_1, obj_2, e)) |
93 | 90 |
94 | 91 |
95 # List subclass we can add attributes to. | 92 # List subclass we can add attributes to. |
96 class MyClassSuite(list): | 93 class MyClassSuite(list): |
97 | 94 |
98 def __init__(self, tests, klass): | 95 def __init__(self, tests, klass): |
99 super(MyClassSuite, self).__init__(tests) | 96 super(MyClassSuite, self).__init__(tests) |
100 | 97 |
(...skipping 2205 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
2306 self.assertIn('a', 'abc') | 2303 self.assertIn('a', 'abc') |
2307 self.assertIn(2, [1, 2, 3]) | 2304 self.assertIn(2, [1, 2, 3]) |
2308 self.assertIn('monkey', animals) | 2305 self.assertIn('monkey', animals) |
2309 | 2306 |
2310 self.assertNotIn('d', 'abc') | 2307 self.assertNotIn('d', 'abc') |
2311 self.assertNotIn(0, [1, 2, 3]) | 2308 self.assertNotIn(0, [1, 2, 3]) |
2312 self.assertNotIn('otter', animals) | 2309 self.assertNotIn('otter', animals) |
2313 | 2310 |
2314 self.assertRaises(self.failureException, self.assertIn, 'x', 'abc') | 2311 self.assertRaises(self.failureException, self.assertIn, 'x', 'abc') |
2315 self.assertRaises(self.failureException, self.assertIn, 4, [1, 2, 3]) | 2312 self.assertRaises(self.failureException, self.assertIn, 4, [1, 2, 3]) |
2316 self.assertRaises(self.failureException, self.assertIn, 'elephant', anim
als) | 2313 self.assertRaises(self.failureException, self.assertIn, 'elephant', |
| 2314 animals) |
2317 | 2315 |
2318 self.assertRaises(self.failureException, self.assertNotIn, 'c', 'abc') | 2316 self.assertRaises(self.failureException, self.assertNotIn, 'c', 'abc') |
2319 self.assertRaises(self.failureException, self.assertNotIn, 1, [1, 2, 3]) | 2317 self.assertRaises(self.failureException, self.assertNotIn, 1, [1, 2, 3]) |
2320 self.assertRaises(self.failureException, self.assertNotIn, 'cow', animal
s) | 2318 self.assertRaises(self.failureException, self.assertNotIn, 'cow', |
| 2319 animals) |
2321 | 2320 |
2322 def testAssertDictContainsSubset(self): | 2321 def testAssertDictContainsSubset(self): |
2323 self.assertDictContainsSubset({}, {}) | 2322 self.assertDictContainsSubset({}, {}) |
2324 self.assertDictContainsSubset({}, {'a': 1}) | 2323 self.assertDictContainsSubset({}, {'a': 1}) |
2325 self.assertDictContainsSubset({'a': 1}, {'a': 1}) | 2324 self.assertDictContainsSubset({'a': 1}, {'a': 1}) |
2326 self.assertDictContainsSubset({'a': 1}, {'a': 1, 'b': 2}) | 2325 self.assertDictContainsSubset({'a': 1}, {'a': 1, 'b': 2}) |
2327 self.assertDictContainsSubset({'a': 1, 'b': 2}, {'a': 1, 'b': 2}) | 2326 self.assertDictContainsSubset({'a': 1, 'b': 2}, {'a': 1, 'b': 2}) |
2328 | 2327 |
2329 self.assertRaises(unittest.TestCase.failureException, | 2328 self.assertRaises(unittest.TestCase.failureException, |
2330 self.assertDictContainsSubset, {'a': 2}, {'a': 1}, | 2329 self.assertDictContainsSubset, {'a': 2}, {'a': 1}, |
(...skipping 42 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
2373 (frozenset([4,5]), set([2,3])), | 2372 (frozenset([4,5]), set([2,3])), |
2374 (set([3,4]), set([5,4]))] | 2373 (set([3,4]), set([5,4]))] |
2375 for a, b in unequal_pairs: | 2374 for a, b in unequal_pairs: |
2376 self.assertRaises(self.failureException, self.assertEqual, a, b) | 2375 self.assertRaises(self.failureException, self.assertEqual, a, b) |
2377 self.assertRaises(self.failureException, self.assertEqual, a, b, | 2376 self.assertRaises(self.failureException, self.assertEqual, a, b, |
2378 'foo') | 2377 'foo') |
2379 self.assertRaises(self.failureException, self.assertEqual, a, b, | 2378 self.assertRaises(self.failureException, self.assertEqual, a, b, |
2380 msg='foo') | 2379 msg='foo') |
2381 | 2380 |
2382 def testEquality(self): | 2381 def testEquality(self): |
2383 self.assertListEquals([], []) | 2382 self.assertListEqual([], []) |
2384 self.assertTupleEquals((), ()) | 2383 self.assertTupleEqual((), ()) |
2385 self.assertSequenceEquals([], ()) | 2384 self.assertSequenceEqual([], ()) |
2386 | 2385 |
2387 a = [0, 'a', []] | 2386 a = [0, 'a', []] |
2388 b = [] | 2387 b = [] |
2389 self.assertRaises(unittest.TestCase.failureException, | 2388 self.assertRaises(unittest.TestCase.failureException, |
2390 self.assertListEquals, a, b) | 2389 self.assertListEqual, a, b) |
2391 self.assertRaises(unittest.TestCase.failureException, | 2390 self.assertRaises(unittest.TestCase.failureException, |
2392 self.assertListEquals, tuple(a), tuple(b)) | 2391 self.assertListEqual, tuple(a), tuple(b)) |
2393 self.assertRaises(unittest.TestCase.failureException, | 2392 self.assertRaises(unittest.TestCase.failureException, |
2394 self.assertSequenceEquals, a, tuple(b)) | 2393 self.assertSequenceEqual, a, tuple(b)) |
2395 | 2394 |
2396 b.extend(a) | 2395 b.extend(a) |
2397 self.assertListEquals(a, b) | 2396 self.assertListEqual(a, b) |
2398 self.assertTupleEquals(tuple(a), tuple(b)) | 2397 self.assertTupleEqual(tuple(a), tuple(b)) |
2399 self.assertSequenceEquals(a, tuple(b)) | 2398 self.assertSequenceEqual(a, tuple(b)) |
2400 self.assertSequenceEquals(tuple(a), b) | 2399 self.assertSequenceEqual(tuple(a), b) |
2401 | 2400 |
2402 self.assertRaises(self.failureException, self.assertListEquals, | 2401 self.assertRaises(self.failureException, self.assertListEqual, |
2403 a, tuple(b)) | 2402 a, tuple(b)) |
2404 self.assertRaises(self.failureException, self.assertTupleEquals, | 2403 self.assertRaises(self.failureException, self.assertTupleEqual, |
2405 tuple(a), b) | 2404 tuple(a), b) |
2406 self.assertRaises(self.failureException, self.assertListEquals, None, b) | 2405 self.assertRaises(self.failureException, self.assertListEqual, None, b) |
2407 self.assertRaises(self.failureException, self.assertTupleEquals, None, | 2406 self.assertRaises(self.failureException, self.assertTupleEqual, None, |
2408 tuple(b)) | 2407 tuple(b)) |
2409 self.assertRaises(self.failureException, self.assertSequenceEquals, | 2408 self.assertRaises(self.failureException, self.assertSequenceEqual, |
2410 None, tuple(b)) | 2409 None, tuple(b)) |
2411 self.assertRaises(self.failureException, self.assertListEquals, 1, 1) | 2410 self.assertRaises(self.failureException, self.assertListEqual, 1, 1) |
2412 self.assertRaises(self.failureException, self.assertTupleEquals, 1, 1) | 2411 self.assertRaises(self.failureException, self.assertTupleEqual, 1, 1) |
2413 self.assertRaises(self.failureException, self.assertSequenceEquals, | 2412 self.assertRaises(self.failureException, self.assertSequenceEqual, |
2414 1, 1) | 2413 1, 1) |
2415 | 2414 |
2416 self.assertDictEquals({}, {}) | 2415 self.assertDictEqual({}, {}) |
2417 | 2416 |
2418 c = { 'x': 1 } | 2417 c = { 'x': 1 } |
2419 d = {} | 2418 d = {} |
2420 self.assertRaises(unittest.TestCase.failureException, | 2419 self.assertRaises(unittest.TestCase.failureException, |
2421 self.assertDictEquals, c, d) | 2420 self.assertDictEqual, c, d) |
2422 | 2421 |
2423 d.update(c) | 2422 d.update(c) |
2424 self.assertDictEquals(c, d) | 2423 self.assertDictEqual(c, d) |
2425 | 2424 |
2426 d['x'] = 0 | 2425 d['x'] = 0 |
2427 self.assertRaises(unittest.TestCase.failureException, | 2426 self.assertRaises(unittest.TestCase.failureException, |
2428 self.assertDictEquals, c, d, 'These are unequal') | 2427 self.assertDictEqual, c, d, 'These are unequal') |
2429 | 2428 |
2430 self.assertRaises(self.failureException, self.assertDictEquals, None, d) | 2429 self.assertRaises(self.failureException, self.assertDictEqual, None, d) |
2431 self.assertRaises(self.failureException, self.assertDictEquals, [], d) | 2430 self.assertRaises(self.failureException, self.assertDictEqual, [], d) |
2432 self.assertRaises(self.failureException, self.assertDictEquals, 1, 1) | 2431 self.assertRaises(self.failureException, self.assertDictEqual, 1, 1) |
2433 | 2432 |
2434 self.assertSameElements([1, 2, 3], [3, 2, 1]) | 2433 self.assertSameElements([1, 2, 3], [3, 2, 1]) |
2435 self.assertSameElements([1, 2] + [3] * 100, [1] * 100 + [2, 3]) | 2434 self.assertSameElements([1, 2] + [3] * 100, [1] * 100 + [2, 3]) |
2436 self.assertSameElements(['foo', 'bar', 'baz'], ['bar', 'baz', 'foo']) | 2435 self.assertSameElements(['foo', 'bar', 'baz'], ['bar', 'baz', 'foo']) |
2437 self.assertRaises(self.failureException, self.assertSameElements, | 2436 self.assertRaises(self.failureException, self.assertSameElements, |
2438 [10], [10, 11]) | 2437 [10], [10, 11]) |
2439 self.assertRaises(self.failureException, self.assertSameElements, | 2438 self.assertRaises(self.failureException, self.assertSameElements, |
2440 [10, 11], [10]) | 2439 [10, 11], [10]) |
2441 | 2440 |
2442 # Test that sequences of unhashable objects can be tested for sameness: | 2441 # Test that sequences of unhashable objects can be tested for sameness: |
2443 self.assertSameElements([[1, 2], [3, 4]], [[3, 4], [1, 2]]) | 2442 self.assertSameElements([[1, 2], [3, 4]], [[3, 4], [1, 2]]) |
2444 self.assertSameElements([{'a': 1}, {'b': 2}], [{'b': 2}, {'a': 1}]) | 2443 self.assertSameElements([{'a': 1}, {'b': 2}], [{'b': 2}, {'a': 1}]) |
2445 self.assertRaises(self.failureException, self.assertSameElements, | 2444 self.assertRaises(self.failureException, self.assertSameElements, |
2446 [[1]], [[2]]) | 2445 [[1]], [[2]]) |
2447 | 2446 |
2448 def testAssertSetEquals(self): | 2447 def testAssertSetEqual(self): |
2449 set1 = set() | 2448 set1 = set() |
2450 set2 = set() | 2449 set2 = set() |
2451 self.assertSetEquals(set1, set2) | 2450 self.assertSetEqual(set1, set2) |
2452 | 2451 |
2453 self.assertRaises(self.failureException, self.assertSetEquals, None, set
2) | 2452 self.assertRaises(self.failureException, self.assertSetEqual, None, set2
) |
2454 self.assertRaises(self.failureException, self.assertSetEquals, [], set2) | 2453 self.assertRaises(self.failureException, self.assertSetEqual, [], set2) |
2455 self.assertRaises(self.failureException, self.assertSetEquals, set1, Non
e) | 2454 self.assertRaises(self.failureException, self.assertSetEqual, set1, None
) |
2456 self.assertRaises(self.failureException, self.assertSetEquals, set1, []) | 2455 self.assertRaises(self.failureException, self.assertSetEqual, set1, []) |
2457 | 2456 |
2458 set1 = set(['a']) | 2457 set1 = set(['a']) |
2459 set2 = set() | 2458 set2 = set() |
2460 self.assertRaises(self.failureException, self.assertSetEquals, set1, set
2) | 2459 self.assertRaises(self.failureException, self.assertSetEqual, set1, set2
) |
2461 | 2460 |
2462 set1 = set(['a']) | 2461 set1 = set(['a']) |
2463 set2 = set(['a']) | 2462 set2 = set(['a']) |
2464 self.assertSetEquals(set1, set2) | 2463 self.assertSetEqual(set1, set2) |
2465 | 2464 |
2466 set1 = set(['a']) | 2465 set1 = set(['a']) |
2467 set2 = set(['a', 'b']) | 2466 set2 = set(['a', 'b']) |
2468 self.assertRaises(self.failureException, self.assertSetEquals, set1, set
2) | 2467 self.assertRaises(self.failureException, self.assertSetEqual, set1, set2
) |
2469 | 2468 |
2470 set1 = set(['a']) | 2469 set1 = set(['a']) |
2471 set2 = frozenset(['a', 'b']) | 2470 set2 = frozenset(['a', 'b']) |
2472 self.assertRaises(self.failureException, self.assertSetEquals, set1, set
2) | 2471 self.assertRaises(self.failureException, self.assertSetEqual, set1, set2
) |
2473 | 2472 |
2474 set1 = set(['a', 'b']) | 2473 set1 = set(['a', 'b']) |
2475 set2 = frozenset(['a', 'b']) | 2474 set2 = frozenset(['a', 'b']) |
2476 self.assertSetEquals(set1, set2) | 2475 self.assertSetEqual(set1, set2) |
2477 | 2476 |
2478 set1 = set() | 2477 set1 = set() |
2479 set2 = "foo" | 2478 set2 = "foo" |
2480 self.assertRaises(self.failureException, self.assertSetEquals, set1, set
2) | 2479 self.assertRaises(self.failureException, self.assertSetEqual, set1, set2
) |
2481 self.assertRaises(self.failureException, self.assertSetEquals, set2, set
1) | 2480 self.assertRaises(self.failureException, self.assertSetEqual, set2, set1
) |
2482 | 2481 |
2483 # make sure any string formatting is tuple-safe | 2482 # make sure any string formatting is tuple-safe |
2484 set1 = set([(0, 1), (2, 3)]) | 2483 set1 = set([(0, 1), (2, 3)]) |
2485 set2 = set([(4, 5)]) | 2484 set2 = set([(4, 5)]) |
2486 self.assertRaises(self.failureException, self.assertSetEquals, set1, set
2) | 2485 self.assertRaises(self.failureException, self.assertSetEqual, set1, set2
) |
2487 | 2486 |
2488 def testInequality(self): | 2487 def testInequality(self): |
2489 # Try ints | 2488 # Try ints |
2490 self.assertGreater(2, 1) | 2489 self.assertGreater(2, 1) |
2491 self.assertGreaterEqual(2, 1) | 2490 self.assertGreaterEqual(2, 1) |
2492 self.assertGreaterEqual(1, 1) | 2491 self.assertGreaterEqual(1, 1) |
2493 self.assertLess(1, 2) | 2492 self.assertLess(1, 2) |
2494 self.assertLessEqual(1, 2) | 2493 self.assertLessEqual(1, 2) |
2495 self.assertLessEqual(1, 1) | 2494 self.assertLessEqual(1, 1) |
2496 self.assertRaises(self.failureException, self.assertGreater, 1, 2) | 2495 self.assertRaises(self.failureException, self.assertGreater, 1, 2) |
(...skipping 67 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
2564 u'bug') | 2563 u'bug') |
2565 self.assertRaises(self.failureException, self.assertGreaterEqual, u'ant'
, | 2564 self.assertRaises(self.failureException, self.assertGreaterEqual, u'ant'
, |
2566 'bug') | 2565 'bug') |
2567 self.assertRaises(self.failureException, self.assertLess, 'bug', u'ant') | 2566 self.assertRaises(self.failureException, self.assertLess, 'bug', u'ant') |
2568 self.assertRaises(self.failureException, self.assertLess, u'bug', 'ant') | 2567 self.assertRaises(self.failureException, self.assertLess, u'bug', 'ant') |
2569 self.assertRaises(self.failureException, self.assertLess, 'ant', u'ant') | 2568 self.assertRaises(self.failureException, self.assertLess, 'ant', u'ant') |
2570 self.assertRaises(self.failureException, self.assertLess, u'ant', 'ant') | 2569 self.assertRaises(self.failureException, self.assertLess, u'ant', 'ant') |
2571 self.assertRaises(self.failureException, self.assertLessEqual, 'bug', u'
ant') | 2570 self.assertRaises(self.failureException, self.assertLessEqual, 'bug', u'
ant') |
2572 self.assertRaises(self.failureException, self.assertLessEqual, u'bug', '
ant') | 2571 self.assertRaises(self.failureException, self.assertLessEqual, u'bug', '
ant') |
2573 | 2572 |
2574 def testAssertMultiLineEquals(self): | 2573 def testAssertMultiLineEqual(self): |
2575 sample_text = b"""\ | 2574 sample_text = b"""\ |
2576 http://www.python.org/doc/2.3/lib/module-unittest.html | 2575 http://www.python.org/doc/2.3/lib/module-unittest.html |
2577 test case | 2576 test case |
2578 A test case is the smallest unit of testing. [...] | 2577 A test case is the smallest unit of testing. [...] |
2579 """ | 2578 """ |
2580 revised_sample_text = b"""\ | 2579 revised_sample_text = b"""\ |
2581 http://www.python.org/doc/2.4.1/lib/module-unittest.html | 2580 http://www.python.org/doc/2.4.1/lib/module-unittest.html |
2582 test case | 2581 test case |
2583 A test case is the smallest unit of testing. [...] You may provide your | 2582 A test case is the smallest unit of testing. [...] You may provide your |
2584 own implementation that does not subclass from TestCase, of course. | 2583 own implementation that does not subclass from TestCase, of course. |
2585 """ | 2584 """ |
2586 sample_text_error = b""" | 2585 sample_text_error = b""" |
2587 - http://www.python.org/doc/2.3/lib/module-unittest.html | 2586 - http://www.python.org/doc/2.3/lib/module-unittest.html |
2588 ? ^ | 2587 ? ^ |
2589 + http://www.python.org/doc/2.4.1/lib/module-unittest.html | 2588 + http://www.python.org/doc/2.4.1/lib/module-unittest.html |
2590 ? ^^^ | 2589 ? ^^^ |
2591 test case | 2590 test case |
2592 - A test case is the smallest unit of testing. [...] | 2591 - A test case is the smallest unit of testing. [...] |
2593 + A test case is the smallest unit of testing. [...] You may provide your | 2592 + A test case is the smallest unit of testing. [...] You may provide your |
2594 ? +++++++++++++++++++++ | 2593 ? +++++++++++++++++++++ |
2595 + own implementation that does not subclass from TestCase, of course. | 2594 + own implementation that does not subclass from TestCase, of course. |
2596 """ | 2595 """ |
2597 | 2596 |
2598 for modifier in (lambda x: x, lambda x: x.decode('utf8')): | 2597 for type_changer in (lambda x: x, lambda x: x.decode('utf8')): |
2599 try: | 2598 try: |
2600 self.assertMultiLineEquals(modifier(sample_text), | 2599 self.assertMultiLineEqual(type_changer(sample_text), |
2601 modifier(revised_sample_text)) | 2600 type_changer(revised_sample_text)) |
2602 except self.failureException, e: | 2601 except self.failureException, e: |
2603 # no fair testing ourself with ourself, use assertEqual.. | 2602 # no fair testing ourself with ourself, use assertEqual.. |
2604 self.assertEqual(sample_text_error, str(e).encode('utf8')) | 2603 self.assertEqual(sample_text_error, str(e).encode('utf8')) |
2605 | 2604 |
2606 def testAssertIsNone(self): | 2605 def testAssertIsNone(self): |
2607 self.assertIsNone(None) | 2606 self.assertIsNone(None) |
2608 self.assertRaises(self.failureException, self.assertIsNone, False) | 2607 self.assertRaises(self.failureException, self.assertIsNone, False) |
2609 self.assertIsNotNone('DjZoPloGears on Rails') | 2608 self.assertIsNotNone('DjZoPloGears on Rails') |
2610 self.assertRaises(self.failureException, self.assertIsNotNone, None) | 2609 self.assertRaises(self.failureException, self.assertIsNotNone, None) |
2611 | 2610 |
2612 def testAssertRegexpMatches(self): | 2611 def testAssertRegexpMatches(self): |
2613 self.assertRegexpMatches('asdfabasdf', r'ab+') | 2612 self.assertRegexpMatches('asdfabasdf', r'ab+') |
2614 self.assertRaises(self.failureException, self.assertRegexpMatches, | 2613 self.assertRaises(self.failureException, self.assertRegexpMatches, |
2615 'saaas', r'aaaa') | 2614 'saaas', r'aaaa') |
2616 | 2615 |
2617 def testAssertRaisesRegexp(self): | 2616 def testAssertRaisesRegexp(self): |
2618 class ExceptionMock(Exception): | 2617 class ExceptionMock(Exception): |
2619 pass | 2618 pass |
2620 | 2619 |
2621 def Stub(): | 2620 def Stub(): |
(...skipping 192 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
2814 ## Main | 2813 ## Main |
2815 ###################################################################### | 2814 ###################################################################### |
2816 | 2815 |
2817 def test_main(): | 2816 def test_main(): |
2818 test_support.run_unittest(Test_TestCase, Test_TestLoader, | 2817 test_support.run_unittest(Test_TestCase, Test_TestLoader, |
2819 Test_TestSuite, Test_TestResult, Test_FunctionTestCase, | 2818 Test_TestSuite, Test_TestResult, Test_FunctionTestCase, |
2820 Test_TestSkipping, Test_Assertions) | 2819 Test_TestSkipping, Test_Assertions) |
2821 | 2820 |
2822 if __name__ == "__main__": | 2821 if __name__ == "__main__": |
2823 test_main() | 2822 test_main() |
LEFT | RIGHT |