Stowage/cpython
2
0
Fork 0
mirror of https://github.com/python/cpython.git synced 2025-10-31 05:31:20 +00:00
Code Issues Projects Releases Packages Wiki Activity

use assert* methods in test_unittest

Browse source
This commit is contained in:
Benjamin Peterson 2009-06-30 23:30:12 +00:00
parent 5c8da86f3a
commit 6b0032f2c3
1 changed files with 53 additions and 53 deletions
Download patch file Download diff file Expand all files Collapse all files

106
Lib/test/test_unittest.py
View file

@ -78,8 +78,8 @@ def test_eq(self):
# Check for a valid __ne__ implementation # Check for a valid __ne__ implementation
def test_ne(self): def test_ne(self):
for obj_1, obj_2 in self.ne_pairs: for obj_1, obj_2 in self.ne_pairs:
self.failIfEqual(obj_1, obj_2) self.assertNotEqual(obj_1, obj_2)
self.failIfEqual(obj_2, obj_1) self.assertNotEqual(obj_2, obj_1)
class TestHashing(object): class TestHashing(object):
"""Used as a mixin for TestCase""" """Used as a mixin for TestCase"""
@ -181,10 +181,10 @@ def runTest(self):
loader = unittest.TestLoader() loader = unittest.TestLoader()
# This has to be false for the test to succeed # This has to be false for the test to succeed
self.failIf('runTest'.startswith(loader.testMethodPrefix)) self.assertFalse('runTest'.startswith(loader.testMethodPrefix))
suite = loader.loadTestsFromTestCase(Foo) suite = loader.loadTestsFromTestCase(Foo)
self.failUnless(isinstance(suite, loader.suiteClass)) self.assertTrue(isinstance(suite, loader.suiteClass))
self.assertEqual(list(suite), [Foo('runTest')]) self.assertEqual(list(suite), [Foo('runTest')])
################################################################ ################################################################
@ -203,7 +203,7 @@ def test(self):
loader = unittest.TestLoader() loader = unittest.TestLoader()
suite = loader.loadTestsFromModule(m) suite = loader.loadTestsFromModule(m)
self.failUnless(isinstance(suite, loader.suiteClass)) self.assertTrue(isinstance(suite, loader.suiteClass))
expected = [loader.suiteClass([MyTestCase('test')])] expected = [loader.suiteClass([MyTestCase('test')])]
self.assertEqual(list(suite), expected) self.assertEqual(list(suite), expected)
@ -216,7 +216,7 @@ def test_loadTestsFromModule__no_TestCase_instances(self):
loader = unittest.TestLoader() loader = unittest.TestLoader()
suite = loader.loadTestsFromModule(m) suite = loader.loadTestsFromModule(m)
self.failUnless(isinstance(suite, loader.suiteClass)) self.assertTrue(isinstance(suite, loader.suiteClass))
self.assertEqual(list(suite), []) self.assertEqual(list(suite), [])
# "This method searches `module` for classes derived from TestCase" # "This method searches `module` for classes derived from TestCase"
@ -230,7 +230,7 @@ class MyTestCase(unittest.TestCase):
loader = unittest.TestLoader() loader = unittest.TestLoader()
suite = loader.loadTestsFromModule(m) suite = loader.loadTestsFromModule(m)
self.failUnless(isinstance(suite, loader.suiteClass)) self.assertTrue(isinstance(suite, loader.suiteClass))
self.assertEqual(list(suite), [loader.suiteClass()]) self.assertEqual(list(suite), [loader.suiteClass()])
@ -466,7 +466,7 @@ def test(self):
loader = unittest.TestLoader() loader = unittest.TestLoader()
suite = loader.loadTestsFromName('testcase_1', m) suite = loader.loadTestsFromName('testcase_1', m)
self.failUnless(isinstance(suite, loader.suiteClass)) self.assertTrue(isinstance(suite, loader.suiteClass))
self.assertEqual(list(suite), [MyTestCase('test')]) self.assertEqual(list(suite), [MyTestCase('test')])
# "The specifier name is a ``dotted name'' that may resolve either to # "The specifier name is a ``dotted name'' that may resolve either to
@ -482,7 +482,7 @@ def test(self):
loader = unittest.TestLoader() loader = unittest.TestLoader()
suite = loader.loadTestsFromName('testsuite', m) suite = loader.loadTestsFromName('testsuite', m)
self.failUnless(isinstance(suite, loader.suiteClass)) self.assertTrue(isinstance(suite, loader.suiteClass))
self.assertEqual(list(suite), [MyTestCase('test')]) self.assertEqual(list(suite), [MyTestCase('test')])
@ -497,7 +497,7 @@ def test(self):
loader = unittest.TestLoader() loader = unittest.TestLoader()
suite = loader.loadTestsFromName('testcase_1.test', m) suite = loader.loadTestsFromName('testcase_1.test', m)
self.failUnless(isinstance(suite, loader.suiteClass)) self.assertTrue(isinstance(suite, loader.suiteClass))
self.assertEqual(list(suite), [MyTestCase('test')]) self.assertEqual(list(suite), [MyTestCase('test')])
@ -536,7 +536,7 @@ def return_TestSuite():
loader = unittest.TestLoader() loader = unittest.TestLoader()
suite = loader.loadTestsFromName('return_TestSuite', m) suite = loader.loadTestsFromName('return_TestSuite', m)
self.failUnless(isinstance(suite, loader.suiteClass)) self.assertTrue(isinstance(suite, loader.suiteClass))
self.assertEqual(list(suite), [testcase_1, testcase_2]) self.assertEqual(list(suite), [testcase_1, testcase_2])
# "The specifier name is a ``dotted name'' that may resolve ... to # "The specifier name is a ``dotted name'' that may resolve ... to
@ -550,7 +550,7 @@ def return_TestCase():
loader = unittest.TestLoader() loader = unittest.TestLoader()
suite = loader.loadTestsFromName('return_TestCase', m) suite = loader.loadTestsFromName('return_TestCase', m)
self.failUnless(isinstance(suite, loader.suiteClass)) self.assertTrue(isinstance(suite, loader.suiteClass))
self.assertEqual(list(suite), [testcase_1]) self.assertEqual(list(suite), [testcase_1])
# "The specifier name is a ``dotted name'' that may resolve ... to # "The specifier name is a ``dotted name'' that may resolve ... to
@ -589,11 +589,11 @@ def test_loadTestsFromName__module_not_loaded(self):
try: try:
suite = loader.loadTestsFromName(module_name) suite = loader.loadTestsFromName(module_name)
self.failUnless(isinstance(suite, loader.suiteClass)) self.assertTrue(isinstance(suite, loader.suiteClass))
self.assertEqual(list(suite), []) self.assertEqual(list(suite), [])
# audioop should now be loaded, thanks to loadTestsFromName() # audioop should now be loaded, thanks to loadTestsFromName()
self.failUnless(module_name in sys.modules) self.assertTrue(module_name in sys.modules)
finally: finally:
if module_name in sys.modules: if module_name in sys.modules:
del sys.modules[module_name] del sys.modules[module_name]
@ -612,7 +612,7 @@ def test_loadTestsFromNames__empty_name_list(self):
loader = unittest.TestLoader() loader = unittest.TestLoader()
suite = loader.loadTestsFromNames([]) suite = loader.loadTestsFromNames([])
self.failUnless(isinstance(suite, loader.suiteClass)) self.assertTrue(isinstance(suite, loader.suiteClass))
self.assertEqual(list(suite), []) self.assertEqual(list(suite), [])
# "Similar to loadTestsFromName(), but takes a sequence of names rather # "Similar to loadTestsFromName(), but takes a sequence of names rather
@ -627,7 +627,7 @@ def test_loadTestsFromNames__relative_empty_name_list(self):
loader = unittest.TestLoader() loader = unittest.TestLoader()
suite = loader.loadTestsFromNames([], unittest) suite = loader.loadTestsFromNames([], unittest)
self.failUnless(isinstance(suite, loader.suiteClass)) self.assertTrue(isinstance(suite, loader.suiteClass))
self.assertEqual(list(suite), []) self.assertEqual(list(suite), [])
# "The specifier name is a ``dotted name'' that may resolve either to # "The specifier name is a ``dotted name'' that may resolve either to
@ -828,7 +828,7 @@ def test(self):
loader = unittest.TestLoader() loader = unittest.TestLoader()
suite = loader.loadTestsFromNames(['testcase_1'], m) suite = loader.loadTestsFromNames(['testcase_1'], m)
self.failUnless(isinstance(suite, loader.suiteClass)) self.assertTrue(isinstance(suite, loader.suiteClass))
expected = loader.suiteClass([MyTestCase('test')]) expected = loader.suiteClass([MyTestCase('test')])
self.assertEqual(list(suite), [expected]) self.assertEqual(list(suite), [expected])
@ -844,7 +844,7 @@ def test(self):
loader = unittest.TestLoader() loader = unittest.TestLoader()
suite = loader.loadTestsFromNames(['testsuite'], m) suite = loader.loadTestsFromNames(['testsuite'], m)
self.failUnless(isinstance(suite, loader.suiteClass)) self.assertTrue(isinstance(suite, loader.suiteClass))
self.assertEqual(list(suite), [m.testsuite]) self.assertEqual(list(suite), [m.testsuite])
@ -859,7 +859,7 @@ def test(self):
loader = unittest.TestLoader() loader = unittest.TestLoader()
suite = loader.loadTestsFromNames(['testcase_1.test'], m) suite = loader.loadTestsFromNames(['testcase_1.test'], m)
self.failUnless(isinstance(suite, loader.suiteClass)) self.assertTrue(isinstance(suite, loader.suiteClass))
ref_suite = unittest.TestSuite([MyTestCase('test')]) ref_suite = unittest.TestSuite([MyTestCase('test')])
self.assertEqual(list(suite), [ref_suite]) self.assertEqual(list(suite), [ref_suite])
@ -896,7 +896,7 @@ def return_TestSuite():
loader = unittest.TestLoader() loader = unittest.TestLoader()
suite = loader.loadTestsFromNames(['return_TestSuite'], m) suite = loader.loadTestsFromNames(['return_TestSuite'], m)
self.failUnless(isinstance(suite, loader.suiteClass)) self.assertTrue(isinstance(suite, loader.suiteClass))
expected = unittest.TestSuite([testcase_1, testcase_2]) expected = unittest.TestSuite([testcase_1, testcase_2])
self.assertEqual(list(suite), [expected]) self.assertEqual(list(suite), [expected])
@ -912,7 +912,7 @@ def return_TestCase():
loader = unittest.TestLoader() loader = unittest.TestLoader()
suite = loader.loadTestsFromNames(['return_TestCase'], m) suite = loader.loadTestsFromNames(['return_TestCase'], m)
self.failUnless(isinstance(suite, loader.suiteClass)) self.assertTrue(isinstance(suite, loader.suiteClass))
ref_suite = unittest.TestSuite([testcase_1]) ref_suite = unittest.TestSuite([testcase_1])
self.assertEqual(list(suite), [ref_suite]) self.assertEqual(list(suite), [ref_suite])
@ -936,7 +936,7 @@ def foo():
loader = unittest.TestLoader() loader = unittest.TestLoader()
suite = loader.loadTestsFromNames(['Foo.foo'], m) suite = loader.loadTestsFromNames(['Foo.foo'], m)
self.failUnless(isinstance(suite, loader.suiteClass)) self.assertTrue(isinstance(suite, loader.suiteClass))
ref_suite = unittest.TestSuite([testcase_1]) ref_suite = unittest.TestSuite([testcase_1])
self.assertEqual(list(suite), [ref_suite]) self.assertEqual(list(suite), [ref_suite])
@ -977,11 +977,11 @@ def test_loadTestsFromNames__module_not_loaded(self):
try: try:
suite = loader.loadTestsFromNames([module_name]) suite = loader.loadTestsFromNames([module_name])
self.failUnless(isinstance(suite, loader.suiteClass)) self.assertTrue(isinstance(suite, loader.suiteClass))
self.assertEqual(list(suite), [unittest.TestSuite()]) self.assertEqual(list(suite), [unittest.TestSuite()])
# audioop should now be loaded, thanks to loadTestsFromName() # audioop should now be loaded, thanks to loadTestsFromName()
self.failUnless(module_name in sys.modules) self.assertTrue(module_name in sys.modules)
finally: finally:
if module_name in sys.modules: if module_name in sys.modules:
del sys.modules[module_name] del sys.modules[module_name]
@ -1156,7 +1156,7 @@ def foo_bar(self): pass
# "The default value is 'test'" # "The default value is 'test'"
def test_testMethodPrefix__default_value(self): def test_testMethodPrefix__default_value(self):
loader = unittest.TestLoader() loader = unittest.TestLoader()
self.failUnless(loader.testMethodPrefix == 'test') self.assertTrue(loader.testMethodPrefix == 'test')
################################################################ ################################################################
### /Tests for TestLoader.testMethodPrefix ### /Tests for TestLoader.testMethodPrefix
@ -1255,7 +1255,7 @@ def test_2(self): pass
# "The default value is the built-in cmp() function" # "The default value is the built-in cmp() function"
def test_sortTestMethodsUsing__default_value(self): def test_sortTestMethodsUsing__default_value(self):
loader = unittest.TestLoader() loader = unittest.TestLoader()
self.failUnless(loader.sortTestMethodsUsing is cmp) self.assertTrue(loader.sortTestMethodsUsing is cmp)
# "it can be set to None to disable the sort." # "it can be set to None to disable the sort."
# #
@ -1342,7 +1342,7 @@ def foo_bar(self): pass
# "The default value is the TestSuite class" # "The default value is the TestSuite class"
def test_suiteClass__default_value(self): def test_suiteClass__default_value(self):
loader = unittest.TestLoader() loader = unittest.TestLoader()
self.failUnless(loader.suiteClass is unittest.TestSuite) self.assertTrue(loader.suiteClass is unittest.TestSuite)
################################################################ ################################################################
### /Tests for TestLoader.suiteClass ### /Tests for TestLoader.suiteClass
@ -1755,7 +1755,7 @@ def tearDown():
def test_id(self): def test_id(self):
test = unittest.FunctionTestCase(lambda: None) test = unittest.FunctionTestCase(lambda: None)
self.failUnless(isinstance(test.id(), basestring)) self.assertTrue(isinstance(test.id(), basestring))
# "Returns a one-line description of the test, or None if no description # "Returns a one-line description of the test, or None if no description
# has been provided. The default implementation of this method returns # has been provided. The default implementation of this method returns
@ -1787,7 +1787,7 @@ class Test_TestResult(TestCase):
def test_init(self): def test_init(self):
result = unittest.TestResult() result = unittest.TestResult()
self.failUnless(result.wasSuccessful()) self.assertTrue(result.wasSuccessful())
self.assertEqual(len(result.errors), 0) self.assertEqual(len(result.errors), 0)
self.assertEqual(len(result.failures), 0) self.assertEqual(len(result.failures), 0)
self.assertEqual(result.testsRun, 0) self.assertEqual(result.testsRun, 0)
@ -1816,7 +1816,7 @@ def test_1(self):
result.startTest(test) result.startTest(test)
self.failUnless(result.wasSuccessful()) self.assertTrue(result.wasSuccessful())
self.assertEqual(len(result.errors), 0) self.assertEqual(len(result.errors), 0)
self.assertEqual(len(result.failures), 0) self.assertEqual(len(result.failures), 0)
self.assertEqual(result.testsRun, 1) self.assertEqual(result.testsRun, 1)
@ -1837,7 +1837,7 @@ def test_1(self):
result.startTest(test) result.startTest(test)
self.failUnless(result.wasSuccessful()) self.assertTrue(result.wasSuccessful())
self.assertEqual(len(result.errors), 0) self.assertEqual(len(result.errors), 0)
self.assertEqual(len(result.failures), 0) self.assertEqual(len(result.failures), 0)
self.assertEqual(result.testsRun, 1) self.assertEqual(result.testsRun, 1)
@ -1846,7 +1846,7 @@ def test_1(self):
result.stopTest(test) result.stopTest(test)
# Same tests as above; make sure nothing has changed # Same tests as above; make sure nothing has changed
self.failUnless(result.wasSuccessful()) self.assertTrue(result.wasSuccessful())
self.assertEqual(len(result.errors), 0) self.assertEqual(len(result.errors), 0)
self.assertEqual(len(result.failures), 0) self.assertEqual(len(result.failures), 0)
self.assertEqual(result.testsRun, 1) self.assertEqual(result.testsRun, 1)
@ -1890,7 +1890,7 @@ def test_1(self):
result.addSuccess(test) result.addSuccess(test)
result.stopTest(test) result.stopTest(test)
self.failUnless(result.wasSuccessful()) self.assertTrue(result.wasSuccessful())
self.assertEqual(len(result.errors), 0) self.assertEqual(len(result.errors), 0)
self.assertEqual(len(result.failures), 0) self.assertEqual(len(result.failures), 0)
self.assertEqual(result.testsRun, 1) self.assertEqual(result.testsRun, 1)
@ -1935,15 +1935,15 @@ def test_1(self):
result.addFailure(test, exc_info_tuple) result.addFailure(test, exc_info_tuple)
result.stopTest(test) result.stopTest(test)
self.failIf(result.wasSuccessful()) self.assertFalse(result.wasSuccessful())
self.assertEqual(len(result.errors), 0) self.assertEqual(len(result.errors), 0)
self.assertEqual(len(result.failures), 1) self.assertEqual(len(result.failures), 1)
self.assertEqual(result.testsRun, 1) self.assertEqual(result.testsRun, 1)
self.assertEqual(result.shouldStop, False) self.assertEqual(result.shouldStop, False)
test_case, formatted_exc = result.failures[0] test_case, formatted_exc = result.failures[0]
self.failUnless(test_case is test) self.assertTrue(test_case is test)
self.failUnless(isinstance(formatted_exc, str)) self.assertTrue(isinstance(formatted_exc, str))
# "addError(test, err)" # "addError(test, err)"
# ... # ...
@ -1985,15 +1985,15 @@ def test_1(self):
result.addError(test, exc_info_tuple) result.addError(test, exc_info_tuple)
result.stopTest(test) result.stopTest(test)
self.failIf(result.wasSuccessful()) self.assertFalse(result.wasSuccessful())
self.assertEqual(len(result.errors), 1) self.assertEqual(len(result.errors), 1)
self.assertEqual(len(result.failures), 0) self.assertEqual(len(result.failures), 0)
self.assertEqual(result.testsRun, 1) self.assertEqual(result.testsRun, 1)
self.assertEqual(result.shouldStop, False) self.assertEqual(result.shouldStop, False)
test_case, formatted_exc = result.errors[0] test_case, formatted_exc = result.errors[0]
self.failUnless(test_case is test) self.assertTrue(test_case is test)
self.failUnless(isinstance(formatted_exc, str)) self.assertTrue(isinstance(formatted_exc, str))
### Support code for Test_TestCase ### Support code for Test_TestCase
################################################################ ################################################################
@ -2307,7 +2307,7 @@ class Foo(unittest.TestCase):
def test(self): def test(self):
pass pass
self.failUnless(Foo('test').failureException is AssertionError) self.assertTrue(Foo('test').failureException is AssertionError)
# "This class attribute gives the exception raised by the test() method. # "This class attribute gives the exception raised by the test() method.
# If a test framework needs to use a specialized exception, possibly to # If a test framework needs to use a specialized exception, possibly to
@ -2325,7 +2325,7 @@ def test(self):
failureException = RuntimeError failureException = RuntimeError
self.failUnless(Foo('test').failureException is RuntimeError) self.assertTrue(Foo('test').failureException is RuntimeError)
Foo('test').run(result) Foo('test').run(result)
@ -2348,7 +2348,7 @@ def test(self):
failureException = RuntimeError failureException = RuntimeError
self.failUnless(Foo('test').failureException is RuntimeError) self.assertTrue(Foo('test').failureException is RuntimeError)
Foo('test').run(result) Foo('test').run(result)
@ -2384,7 +2384,7 @@ class Foo(unittest.TestCase):
def runTest(self): def runTest(self):
pass pass
self.failUnless(isinstance(Foo().id(), basestring)) self.assertTrue(isinstance(Foo().id(), basestring))
# "If result is omitted or None, a temporary result object is created # "If result is omitted or None, a temporary result object is created
# and used, but is not made available to the caller. As TestCase owns the # and used, but is not made available to the caller. As TestCase owns the
@ -2955,23 +2955,23 @@ def test_die(self):
class Test_Assertions(TestCase): class Test_Assertions(TestCase):
def test_AlmostEqual(self): def test_AlmostEqual(self):
self.failUnlessAlmostEqual(1.00000001, 1.0) self.assertAlmostEqual(1.00000001, 1.0)
self.failIfAlmostEqual(1.0000001, 1.0) self.assertNotAlmostEqual(1.0000001, 1.0)
self.assertRaises(self.failureException, self.assertRaises(self.failureException,
self.failUnlessAlmostEqual, 1.0000001, 1.0) self.assertAlmostEqual, 1.0000001, 1.0)
self.assertRaises(self.failureException, self.assertRaises(self.failureException,
self.failIfAlmostEqual, 1.00000001, 1.0) self.assertNotAlmostEqual, 1.00000001, 1.0)
self.failUnlessAlmostEqual(1.1, 1.0, places=0) self.assertAlmostEqual(1.1, 1.0, places=0)
self.assertRaises(self.failureException, self.assertRaises(self.failureException,
self.failUnlessAlmostEqual, 1.1, 1.0, places=1) self.assertAlmostEqual, 1.1, 1.0, places=1)
self.failUnlessAlmostEqual(0, .1+.1j, places=0) self.assertAlmostEqual(0, .1+.1j, places=0)
self.failIfAlmostEqual(0, .1+.1j, places=1) self.assertNotAlmostEqual(0, .1+.1j, places=1)
self.assertRaises(self.failureException, self.assertRaises(self.failureException,
self.failUnlessAlmostEqual, 0, .1+.1j, places=1) self.assertAlmostEqual, 0, .1+.1j, places=1)
self.assertRaises(self.failureException, self.assertRaises(self.failureException,
self.failIfAlmostEqual, 0, .1+.1j, places=0) self.assertNotAlmostEqual, 0, .1+.1j, places=0)
def test_assertRaises(self): def test_assertRaises(self):
def _raise(e): def _raise(e):