Thanks to visit codestin.com
Credit goes to github.com

Skip to content

Commit e1759f8

Browse files
benjaminpbenjaminp
committed
Merged revisions 73717 via svnmerge from
svn+ssh://[email protected]/python/trunk ........ r73717 | benjamin.peterson | 2009-06-30 18:30:12 -0500 (Tue, 30 Jun 2009) | 1 line use assert* methods in test_unittest ........
1 parent 5e474d3 commit e1759f8

1 file changed

Lines changed: 51 additions & 51 deletions

File tree

‎Lib/test/test_unittest.py‎

Lines changed: 51 additions & 51 deletions
Original file line numberDiff line numberDiff line change
@@ -77,8 +77,8 @@ def test_eq(self):
7777
# Check for a valid __ne__ implementation
7878
def test_ne(self):
7979
for obj_1, obj_2 in self.ne_pairs:
80-
self.failIfEqual(obj_1, obj_2)
81-
self.failIfEqual(obj_2, obj_1)
80+
self.assertNotEqual(obj_1, obj_2)
81+
self.assertNotEqual(obj_2, obj_1)
8282

8383
class TestHashing(object):
8484
"""Used as a mixin for TestCase"""
@@ -180,10 +180,10 @@ def runTest(self):
180180

181181
loader = unittest.TestLoader()
182182
# This has to be false for the test to succeed
183-
self.failIf('runTest'.startswith(loader.testMethodPrefix))
183+
self.assertFalse('runTest'.startswith(loader.testMethodPrefix))
184184

185185
suite = loader.loadTestsFromTestCase(Foo)
186-
self.failUnless(isinstance(suite, loader.suiteClass))
186+
self.assertTrue(isinstance(suite, loader.suiteClass))
187187
self.assertEqual(list(suite), [Foo('runTest')])
188188

189189
################################################################
@@ -202,7 +202,7 @@ def test(self):
202202

203203
loader = unittest.TestLoader()
204204
suite = loader.loadTestsFromModule(m)
205-
self.failUnless(isinstance(suite, loader.suiteClass))
205+
self.assertTrue(isinstance(suite, loader.suiteClass))
206206

207207
expected = [loader.suiteClass([MyTestCase('test')])]
208208
self.assertEqual(list(suite), expected)
@@ -215,7 +215,7 @@ def test_loadTestsFromModule__no_TestCase_instances(self):
215215

216216
loader = unittest.TestLoader()
217217
suite = loader.loadTestsFromModule(m)
218-
self.failUnless(isinstance(suite, loader.suiteClass))
218+
self.assertTrue(isinstance(suite, loader.suiteClass))
219219
self.assertEqual(list(suite), [])
220220

221221
# "This method searches `module` for classes derived from TestCase"
@@ -229,7 +229,7 @@ class MyTestCase(unittest.TestCase):
229229

230230
loader = unittest.TestLoader()
231231
suite = loader.loadTestsFromModule(m)
232-
self.failUnless(isinstance(suite, loader.suiteClass))
232+
self.assertTrue(isinstance(suite, loader.suiteClass))
233233

234234
self.assertEqual(list(suite), [loader.suiteClass()])
235235

@@ -465,7 +465,7 @@ def test(self):
465465

466466
loader = unittest.TestLoader()
467467
suite = loader.loadTestsFromName('testcase_1', m)
468-
self.failUnless(isinstance(suite, loader.suiteClass))
468+
self.assertTrue(isinstance(suite, loader.suiteClass))
469469
self.assertEqual(list(suite), [MyTestCase('test')])
470470

471471
# "The specifier name is a ``dotted name'' that may resolve either to
@@ -481,7 +481,7 @@ def test(self):
481481

482482
loader = unittest.TestLoader()
483483
suite = loader.loadTestsFromName('testsuite', m)
484-
self.failUnless(isinstance(suite, loader.suiteClass))
484+
self.assertTrue(isinstance(suite, loader.suiteClass))
485485

486486
self.assertEqual(list(suite), [MyTestCase('test')])
487487

@@ -496,7 +496,7 @@ def test(self):
496496

497497
loader = unittest.TestLoader()
498498
suite = loader.loadTestsFromName('testcase_1.test', m)
499-
self.failUnless(isinstance(suite, loader.suiteClass))
499+
self.assertTrue(isinstance(suite, loader.suiteClass))
500500

501501
self.assertEqual(list(suite), [MyTestCase('test')])
502502

@@ -535,7 +535,7 @@ def return_TestSuite():
535535

536536
loader = unittest.TestLoader()
537537
suite = loader.loadTestsFromName('return_TestSuite', m)
538-
self.failUnless(isinstance(suite, loader.suiteClass))
538+
self.assertTrue(isinstance(suite, loader.suiteClass))
539539
self.assertEqual(list(suite), [testcase_1, testcase_2])
540540

541541
# "The specifier name is a ``dotted name'' that may resolve ... to
@@ -549,7 +549,7 @@ def return_TestCase():
549549

550550
loader = unittest.TestLoader()
551551
suite = loader.loadTestsFromName('return_TestCase', m)
552-
self.failUnless(isinstance(suite, loader.suiteClass))
552+
self.assertTrue(isinstance(suite, loader.suiteClass))
553553
self.assertEqual(list(suite), [testcase_1])
554554

555555
# "The specifier name is a ``dotted name'' that may resolve ... to
@@ -588,11 +588,11 @@ def test_loadTestsFromName__module_not_loaded(self):
588588
try:
589589
suite = loader.loadTestsFromName(module_name)
590590

591-
self.failUnless(isinstance(suite, loader.suiteClass))
591+
self.assertTrue(isinstance(suite, loader.suiteClass))
592592
self.assertEqual(list(suite), [])
593593

594594
# audioop should now be loaded, thanks to loadTestsFromName()
595-
self.failUnless(module_name in sys.modules)
595+
self.assertTrue(module_name in sys.modules)
596596
finally:
597597
if module_name in sys.modules:
598598
del sys.modules[module_name]
@@ -611,7 +611,7 @@ def test_loadTestsFromNames__empty_name_list(self):
611611
loader = unittest.TestLoader()
612612

613613
suite = loader.loadTestsFromNames([])
614-
self.failUnless(isinstance(suite, loader.suiteClass))
614+
self.assertTrue(isinstance(suite, loader.suiteClass))
615615
self.assertEqual(list(suite), [])
616616

617617
# "Similar to loadTestsFromName(), but takes a sequence of names rather
@@ -626,7 +626,7 @@ def test_loadTestsFromNames__relative_empty_name_list(self):
626626
loader = unittest.TestLoader()
627627

628628
suite = loader.loadTestsFromNames([], unittest)
629-
self.failUnless(isinstance(suite, loader.suiteClass))
629+
self.assertTrue(isinstance(suite, loader.suiteClass))
630630
self.assertEqual(list(suite), [])
631631

632632
# "The specifier name is a ``dotted name'' that may resolve either to
@@ -827,7 +827,7 @@ def test(self):
827827

828828
loader = unittest.TestLoader()
829829
suite = loader.loadTestsFromNames(['testcase_1'], m)
830-
self.failUnless(isinstance(suite, loader.suiteClass))
830+
self.assertTrue(isinstance(suite, loader.suiteClass))
831831

832832
expected = loader.suiteClass([MyTestCase('test')])
833833
self.assertEqual(list(suite), [expected])
@@ -843,7 +843,7 @@ def test(self):
843843

844844
loader = unittest.TestLoader()
845845
suite = loader.loadTestsFromNames(['testsuite'], m)
846-
self.failUnless(isinstance(suite, loader.suiteClass))
846+
self.assertTrue(isinstance(suite, loader.suiteClass))
847847

848848
self.assertEqual(list(suite), [m.testsuite])
849849

@@ -858,7 +858,7 @@ def test(self):
858858

859859
loader = unittest.TestLoader()
860860
suite = loader.loadTestsFromNames(['testcase_1.test'], m)
861-
self.failUnless(isinstance(suite, loader.suiteClass))
861+
self.assertTrue(isinstance(suite, loader.suiteClass))
862862

863863
ref_suite = unittest.TestSuite([MyTestCase('test')])
864864
self.assertEqual(list(suite), [ref_suite])
@@ -895,7 +895,7 @@ def return_TestSuite():
895895

896896
loader = unittest.TestLoader()
897897
suite = loader.loadTestsFromNames(['return_TestSuite'], m)
898-
self.failUnless(isinstance(suite, loader.suiteClass))
898+
self.assertTrue(isinstance(suite, loader.suiteClass))
899899

900900
expected = unittest.TestSuite([testcase_1, testcase_2])
901901
self.assertEqual(list(suite), [expected])
@@ -911,7 +911,7 @@ def return_TestCase():
911911

912912
loader = unittest.TestLoader()
913913
suite = loader.loadTestsFromNames(['return_TestCase'], m)
914-
self.failUnless(isinstance(suite, loader.suiteClass))
914+
self.assertTrue(isinstance(suite, loader.suiteClass))
915915

916916
ref_suite = unittest.TestSuite([testcase_1])
917917
self.assertEqual(list(suite), [ref_suite])
@@ -935,7 +935,7 @@ def foo():
935935

936936
loader = unittest.TestLoader()
937937
suite = loader.loadTestsFromNames(['Foo.foo'], m)
938-
self.failUnless(isinstance(suite, loader.suiteClass))
938+
self.assertTrue(isinstance(suite, loader.suiteClass))
939939

940940
ref_suite = unittest.TestSuite([testcase_1])
941941
self.assertEqual(list(suite), [ref_suite])
@@ -976,11 +976,11 @@ def test_loadTestsFromNames__module_not_loaded(self):
976976
try:
977977
suite = loader.loadTestsFromNames([module_name])
978978

979-
self.failUnless(isinstance(suite, loader.suiteClass))
979+
self.assertTrue(isinstance(suite, loader.suiteClass))
980980
self.assertEqual(list(suite), [unittest.TestSuite()])
981981

982982
# audioop should now be loaded, thanks to loadTestsFromName()
983-
self.failUnless(module_name in sys.modules)
983+
self.assertTrue(module_name in sys.modules)
984984
finally:
985985
if module_name in sys.modules:
986986
del sys.modules[module_name]
@@ -1351,7 +1351,7 @@ def foo_bar(self): pass
13511351
# "The default value is the TestSuite class"
13521352
def test_suiteClass__default_value(self):
13531353
loader = unittest.TestLoader()
1354-
self.failUnless(loader.suiteClass is unittest.TestSuite)
1354+
self.assertTrue(loader.suiteClass is unittest.TestSuite)
13551355

13561356
################################################################
13571357
### /Tests for TestLoader.suiteClass
@@ -1764,7 +1764,7 @@ def tearDown():
17641764
def test_id(self):
17651765
test = unittest.FunctionTestCase(lambda: None)
17661766

1767-
self.failUnless(isinstance(test.id(), str))
1767+
self.assertTrue(isinstance(test.id(), str))
17681768

17691769
# "Returns a one-line description of the test, or None if no description
17701770
# has been provided. The default implementation of this method returns
@@ -1796,7 +1796,7 @@ class Test_TestResult(TestCase):
17961796
def test_init(self):
17971797
result = unittest.TestResult()
17981798

1799-
self.failUnless(result.wasSuccessful())
1799+
self.assertTrue(result.wasSuccessful())
18001800
self.assertEqual(len(result.errors), 0)
18011801
self.assertEqual(len(result.failures), 0)
18021802
self.assertEqual(result.testsRun, 0)
@@ -1825,7 +1825,7 @@ def test_1(self):
18251825

18261826
result.startTest(test)
18271827

1828-
self.failUnless(result.wasSuccessful())
1828+
self.assertTrue(result.wasSuccessful())
18291829
self.assertEqual(len(result.errors), 0)
18301830
self.assertEqual(len(result.failures), 0)
18311831
self.assertEqual(result.testsRun, 1)
@@ -1846,7 +1846,7 @@ def test_1(self):
18461846

18471847
result.startTest(test)
18481848

1849-
self.failUnless(result.wasSuccessful())
1849+
self.assertTrue(result.wasSuccessful())
18501850
self.assertEqual(len(result.errors), 0)
18511851
self.assertEqual(len(result.failures), 0)
18521852
self.assertEqual(result.testsRun, 1)
@@ -1855,7 +1855,7 @@ def test_1(self):
18551855
result.stopTest(test)
18561856

18571857
# Same tests as above; make sure nothing has changed
1858-
self.failUnless(result.wasSuccessful())
1858+
self.assertTrue(result.wasSuccessful())
18591859
self.assertEqual(len(result.errors), 0)
18601860
self.assertEqual(len(result.failures), 0)
18611861
self.assertEqual(result.testsRun, 1)
@@ -1899,7 +1899,7 @@ def test_1(self):
18991899
result.addSuccess(test)
19001900
result.stopTest(test)
19011901

1902-
self.failUnless(result.wasSuccessful())
1902+
self.assertTrue(result.wasSuccessful())
19031903
self.assertEqual(len(result.errors), 0)
19041904
self.assertEqual(len(result.failures), 0)
19051905
self.assertEqual(result.testsRun, 1)
@@ -1944,15 +1944,15 @@ def test_1(self):
19441944
result.addFailure(test, exc_info_tuple)
19451945
result.stopTest(test)
19461946

1947-
self.failIf(result.wasSuccessful())
1947+
self.assertFalse(result.wasSuccessful())
19481948
self.assertEqual(len(result.errors), 0)
19491949
self.assertEqual(len(result.failures), 1)
19501950
self.assertEqual(result.testsRun, 1)
19511951
self.assertEqual(result.shouldStop, False)
19521952

19531953
test_case, formatted_exc = result.failures[0]
1954-
self.failUnless(test_case is test)
1955-
self.failUnless(isinstance(formatted_exc, str))
1954+
self.assertTrue(test_case is test)
1955+
self.assertTrue(isinstance(formatted_exc, str))
19561956

19571957
# "addError(test, err)"
19581958
# ...
@@ -1994,15 +1994,15 @@ def test_1(self):
19941994
result.addError(test, exc_info_tuple)
19951995
result.stopTest(test)
19961996

1997-
self.failIf(result.wasSuccessful())
1997+
self.assertFalse(result.wasSuccessful())
19981998
self.assertEqual(len(result.errors), 1)
19991999
self.assertEqual(len(result.failures), 0)
20002000
self.assertEqual(result.testsRun, 1)
20012001
self.assertEqual(result.shouldStop, False)
20022002

20032003
test_case, formatted_exc = result.errors[0]
2004-
self.failUnless(test_case is test)
2005-
self.failUnless(isinstance(formatted_exc, str))
2004+
self.assertTrue(test_case is test)
2005+
self.assertTrue(isinstance(formatted_exc, str))
20062006

20072007
### Support code for Test_TestCase
20082008
################################################################
@@ -2316,7 +2316,7 @@ class Foo(unittest.TestCase):
23162316
def test(self):
23172317
pass
23182318

2319-
self.failUnless(Foo('test').failureException is AssertionError)
2319+
self.assertTrue(Foo('test').failureException is AssertionError)
23202320

23212321
# "This class attribute gives the exception raised by the test() method.
23222322
# If a test framework needs to use a specialized exception, possibly to
@@ -2334,7 +2334,7 @@ def test(self):
23342334

23352335
failureException = RuntimeError
23362336

2337-
self.failUnless(Foo('test').failureException is RuntimeError)
2337+
self.assertTrue(Foo('test').failureException is RuntimeError)
23382338

23392339

23402340
Foo('test').run(result)
@@ -2357,7 +2357,7 @@ def test(self):
23572357

23582358
failureException = RuntimeError
23592359

2360-
self.failUnless(Foo('test').failureException is RuntimeError)
2360+
self.assertTrue(Foo('test').failureException is RuntimeError)
23612361

23622362

23632363
Foo('test').run(result)
@@ -2393,7 +2393,7 @@ class Foo(unittest.TestCase):
23932393
def runTest(self):
23942394
pass
23952395

2396-
self.failUnless(isinstance(Foo().id(), str))
2396+
self.assertTrue(isinstance(Foo().id(), str))
23972397

23982398
# "If result is omitted or None, a temporary result object is created
23992399
# and used, but is not made available to the caller. As TestCase owns the
@@ -2926,23 +2926,23 @@ def test_die(self):
29262926

29272927
class Test_Assertions(TestCase):
29282928
def test_AlmostEqual(self):
2929-
self.failUnlessAlmostEqual(1.00000001, 1.0)
2930-
self.failIfAlmostEqual(1.0000001, 1.0)
2929+
self.assertAlmostEqual(1.00000001, 1.0)
2930+
self.assertNotAlmostEqual(1.0000001, 1.0)
29312931
self.assertRaises(self.failureException,
2932-
self.failUnlessAlmostEqual, 1.0000001, 1.0)
2932+
self.assertAlmostEqual, 1.0000001, 1.0)
29332933
self.assertRaises(self.failureException,
2934-
self.failIfAlmostEqual, 1.00000001, 1.0)
2934+
self.assertNotAlmostEqual, 1.00000001, 1.0)
29352935

2936-
self.failUnlessAlmostEqual(1.1, 1.0, places=0)
2936+
self.assertAlmostEqual(1.1, 1.0, places=0)
29372937
self.assertRaises(self.failureException,
2938-
self.failUnlessAlmostEqual, 1.1, 1.0, places=1)
2938+
self.assertAlmostEqual, 1.1, 1.0, places=1)
29392939

2940-
self.failUnlessAlmostEqual(0, .1+.1j, places=0)
2941-
self.failIfAlmostEqual(0, .1+.1j, places=1)
2940+
self.assertAlmostEqual(0, .1+.1j, places=0)
2941+
self.assertNotAlmostEqual(0, .1+.1j, places=1)
29422942
self.assertRaises(self.failureException,
2943-
self.failUnlessAlmostEqual, 0, .1+.1j, places=1)
2943+
self.assertAlmostEqual, 0, .1+.1j, places=1)
29442944
self.assertRaises(self.failureException,
2945-
self.failIfAlmostEqual, 0, .1+.1j, places=0)
2945+
self.assertNotAlmostEqual, 0, .1+.1j, places=0)
29462946

29472947
def test_assertRaises(self):
29482948
def _raise(e):

0 commit comments

Comments
 (0)