mirrors/cpython
1
0
Fork 0
mirror of https://github.com/python/cpython.git synced 2025-07-19 09:15:34 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions 6

Merged revisions 73718,73721,73723 via svnmerge from

Browse source 
svn+ssh://svn.python.org/python/branches/py3k

................
  r73718 | benjamin.peterson | 2009-07-01 01:35:19 +0200 (Mi, 01 Jul 2009) | 9 lines

  Merged revisions 73717 via svnmerge from
  svn+ssh://pythondev@svn.python.org/python/trunk

  ........
    r73717 | benjamin.peterson | 2009-06-30 18:30:12 -0500 (Tue, 30 Jun 2009) | 1 line

    use assert* methods in test_unittest
  ........
................
  r73721 | benjamin.peterson | 2009-07-01 02:43:10 +0200 (Mi, 01 Jul 2009) | 11 lines

  Merged revisions 73720 via svnmerge from
  svn+ssh://pythondev@svn.python.org/python/trunk

  ........
    r73720 | benjamin.peterson | 2009-06-30 19:36:41 -0500 (Tue, 30 Jun 2009) | 4 lines

    fix a few cases where automated fail -> assert translation messed up

    Thanks Joe Amenta
  ........
................
  r73723 | benjamin.peterson | 2009-07-01 02:45:43 +0200 (Mi, 01 Jul 2009) | 1 line

  remove use of failIf
................
This commit is contained in:
Georg Brandl 2009-08-13 08:52:53 +00:00
parent ab91fdef1f
commit fe5f11c684
4 changed files with 77 additions and 77 deletions
Download patch file Download diff file Expand all files Collapse all files

102
Lib/test/test_unittest.py
View file

@ -75,8 +75,8 @@ class TestEquality(object):
# Check for a valid __ne__ implementation
def test_ne(self):
for obj_1, obj_2 in self.ne_pairs:
self.failIfEqual(obj_1, obj_2)
self.failIfEqual(obj_2, obj_1)
self.assertNotEqual(obj_1, obj_2)
self.assertNotEqual(obj_2, obj_1)
class TestHashing(object):
"""Used as a mixin for TestCase"""
@ -178,10 +178,10 @@ class Test_TestLoader(TestCase):
loader = unittest.TestLoader()
# 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)
self.failUnless(isinstance(suite, loader.suiteClass))
self.assertTrue(isinstance(suite, loader.suiteClass))
self.assertEqual(list(suite), [Foo('runTest')])
################################################################
@ -200,7 +200,7 @@ class Test_TestLoader(TestCase):
loader = unittest.TestLoader()
suite = loader.loadTestsFromModule(m)
self.failUnless(isinstance(suite, loader.suiteClass))
self.assertTrue(isinstance(suite, loader.suiteClass))
expected = [loader.suiteClass([MyTestCase('test')])]
self.assertEqual(list(suite), expected)
@ -213,7 +213,7 @@ class Test_TestLoader(TestCase):
loader = unittest.TestLoader()
suite = loader.loadTestsFromModule(m)
self.failUnless(isinstance(suite, loader.suiteClass))
self.assertTrue(isinstance(suite, loader.suiteClass))
self.assertEqual(list(suite), [])
# "This method searches `module` for classes derived from TestCase"
@ -227,7 +227,7 @@ class Test_TestLoader(TestCase):
loader = unittest.TestLoader()
suite = loader.loadTestsFromModule(m)
self.failUnless(isinstance(suite, loader.suiteClass))
self.assertTrue(isinstance(suite, loader.suiteClass))
self.assertEqual(list(suite), [loader.suiteClass()])
@ -439,7 +439,7 @@ class Test_TestLoader(TestCase):
loader = unittest.TestLoader()
suite = loader.loadTestsFromName('testcase_1', m)
self.failUnless(isinstance(suite, loader.suiteClass))
self.assertTrue(isinstance(suite, loader.suiteClass))
self.assertEqual(list(suite), [MyTestCase('test')])
# "The specifier name is a ``dotted name'' that may resolve either to
@ -455,7 +455,7 @@ class Test_TestLoader(TestCase):
loader = unittest.TestLoader()
suite = loader.loadTestsFromName('testsuite', m)
self.failUnless(isinstance(suite, loader.suiteClass))
self.assertTrue(isinstance(suite, loader.suiteClass))
self.assertEqual(list(suite), [MyTestCase('test')])
@ -470,7 +470,7 @@ class Test_TestLoader(TestCase):
loader = unittest.TestLoader()
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')])
@ -509,7 +509,7 @@ class Test_TestLoader(TestCase):
loader = unittest.TestLoader()
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])
# "The specifier name is a ``dotted name'' that may resolve ... to
@ -523,7 +523,7 @@ class Test_TestLoader(TestCase):
loader = unittest.TestLoader()
suite = loader.loadTestsFromName('return_TestCase', m)
self.failUnless(isinstance(suite, loader.suiteClass))
self.assertTrue(isinstance(suite, loader.suiteClass))
self.assertEqual(list(suite), [testcase_1])
# "The specifier name is a ``dotted name'' that may resolve ... to
@ -562,11 +562,11 @@ class Test_TestLoader(TestCase):
try:
suite = loader.loadTestsFromName(module_name)
self.failUnless(isinstance(suite, loader.suiteClass))
self.assertTrue(isinstance(suite, loader.suiteClass))
self.assertEqual(list(suite), [])
# audioop should now be loaded, thanks to loadTestsFromName()
self.failUnless(module_name in sys.modules)
self.assertTrue(module_name in sys.modules)
finally:
if module_name in sys.modules:
del sys.modules[module_name]
@ -585,7 +585,7 @@ class Test_TestLoader(TestCase):
loader = unittest.TestLoader()
suite = loader.loadTestsFromNames([])
self.failUnless(isinstance(suite, loader.suiteClass))
self.assertTrue(isinstance(suite, loader.suiteClass))
self.assertEqual(list(suite), [])
# "Similar to loadTestsFromName(), but takes a sequence of names rather
@ -600,7 +600,7 @@ class Test_TestLoader(TestCase):
loader = unittest.TestLoader()
suite = loader.loadTestsFromNames([], unittest)
self.failUnless(isinstance(suite, loader.suiteClass))
self.assertTrue(isinstance(suite, loader.suiteClass))
self.assertEqual(list(suite), [])
# "The specifier name is a ``dotted name'' that may resolve either to
@ -801,7 +801,7 @@ class Test_TestLoader(TestCase):
loader = unittest.TestLoader()
suite = loader.loadTestsFromNames(['testcase_1'], m)
self.failUnless(isinstance(suite, loader.suiteClass))
self.assertTrue(isinstance(suite, loader.suiteClass))
expected = loader.suiteClass([MyTestCase('test')])
self.assertEqual(list(suite), [expected])
@ -817,7 +817,7 @@ class Test_TestLoader(TestCase):
loader = unittest.TestLoader()
suite = loader.loadTestsFromNames(['testsuite'], m)
self.failUnless(isinstance(suite, loader.suiteClass))
self.assertTrue(isinstance(suite, loader.suiteClass))
self.assertEqual(list(suite), [m.testsuite])
@ -832,7 +832,7 @@ class Test_TestLoader(TestCase):
loader = unittest.TestLoader()
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')])
self.assertEqual(list(suite), [ref_suite])
@ -869,7 +869,7 @@ class Test_TestLoader(TestCase):
loader = unittest.TestLoader()
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])
self.assertEqual(list(suite), [expected])
@ -885,7 +885,7 @@ class Test_TestLoader(TestCase):
loader = unittest.TestLoader()
suite = loader.loadTestsFromNames(['return_TestCase'], m)
self.failUnless(isinstance(suite, loader.suiteClass))
self.assertTrue(isinstance(suite, loader.suiteClass))
ref_suite = unittest.TestSuite([testcase_1])
self.assertEqual(list(suite), [ref_suite])
@ -909,7 +909,7 @@ class Test_TestLoader(TestCase):
loader = unittest.TestLoader()
suite = loader.loadTestsFromNames(['Foo.foo'], m)
self.failUnless(isinstance(suite, loader.suiteClass))
self.assertTrue(isinstance(suite, loader.suiteClass))
ref_suite = unittest.TestSuite([testcase_1])
self.assertEqual(list(suite), [ref_suite])
@ -950,11 +950,11 @@ class Test_TestLoader(TestCase):
try:
suite = loader.loadTestsFromNames([module_name])
self.failUnless(isinstance(suite, loader.suiteClass))
self.assertTrue(isinstance(suite, loader.suiteClass))
self.assertEqual(list(suite), [unittest.TestSuite()])
# audioop should now be loaded, thanks to loadTestsFromName()
self.failUnless(module_name in sys.modules)
self.assertTrue(module_name in sys.modules)
finally:
if module_name in sys.modules:
del sys.modules[module_name]
@ -1325,7 +1325,7 @@ class Test_TestLoader(TestCase):
# "The default value is the TestSuite class"
def test_suiteClass__default_value(self):
loader = unittest.TestLoader()
self.failUnless(loader.suiteClass is unittest.TestSuite)
self.assertTrue(loader.suiteClass is unittest.TestSuite)
################################################################
### /Tests for TestLoader.suiteClass
@ -1738,7 +1738,7 @@ class Test_FunctionTestCase(TestCase):
def test_id(self):
test = unittest.FunctionTestCase(lambda: None)
self.failUnless(isinstance(test.id(), str))
self.assertTrue(isinstance(test.id(), str))
# "Returns a one-line description of the test, or None if no description
# has been provided. The default implementation of this method returns
@ -1770,7 +1770,7 @@ class Test_TestResult(TestCase):
def test_init(self):
result = unittest.TestResult()
self.failUnless(result.wasSuccessful())
self.assertTrue(result.wasSuccessful())
self.assertEqual(len(result.errors), 0)
self.assertEqual(len(result.failures), 0)
self.assertEqual(result.testsRun, 0)
@ -1799,7 +1799,7 @@ class Test_TestResult(TestCase):
result.startTest(test)
self.failUnless(result.wasSuccessful())
self.assertTrue(result.wasSuccessful())
self.assertEqual(len(result.errors), 0)
self.assertEqual(len(result.failures), 0)
self.assertEqual(result.testsRun, 1)
@ -1820,7 +1820,7 @@ class Test_TestResult(TestCase):
result.startTest(test)
self.failUnless(result.wasSuccessful())
self.assertTrue(result.wasSuccessful())
self.assertEqual(len(result.errors), 0)
self.assertEqual(len(result.failures), 0)
self.assertEqual(result.testsRun, 1)
@ -1829,7 +1829,7 @@ class Test_TestResult(TestCase):
result.stopTest(test)
# 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.failures), 0)
self.assertEqual(result.testsRun, 1)
@ -1873,7 +1873,7 @@ class Test_TestResult(TestCase):
result.addSuccess(test)
result.stopTest(test)
self.failUnless(result.wasSuccessful())
self.assertTrue(result.wasSuccessful())
self.assertEqual(len(result.errors), 0)
self.assertEqual(len(result.failures), 0)
self.assertEqual(result.testsRun, 1)
@ -1918,15 +1918,15 @@ class Test_TestResult(TestCase):
result.addFailure(test, exc_info_tuple)
result.stopTest(test)
self.failIf(result.wasSuccessful())
self.assertFalse(result.wasSuccessful())
self.assertEqual(len(result.errors), 0)
self.assertEqual(len(result.failures), 1)
self.assertEqual(result.testsRun, 1)
self.assertEqual(result.shouldStop, False)
test_case, formatted_exc = result.failures[0]
self.failUnless(test_case is test)
self.failUnless(isinstance(formatted_exc, str))
self.assertTrue(test_case is test)
self.assertTrue(isinstance(formatted_exc, str))
# "addError(test, err)"
# ...
@ -1968,15 +1968,15 @@ class Test_TestResult(TestCase):
result.addError(test, exc_info_tuple)
result.stopTest(test)
self.failIf(result.wasSuccessful())
self.assertFalse(result.wasSuccessful())
self.assertEqual(len(result.errors), 1)
self.assertEqual(len(result.failures), 0)
self.assertEqual(result.testsRun, 1)
self.assertEqual(result.shouldStop, False)
test_case, formatted_exc = result.errors[0]
self.failUnless(test_case is test)
self.failUnless(isinstance(formatted_exc, str))
self.assertTrue(test_case is test)
self.assertTrue(isinstance(formatted_exc, str))
### Support code for Test_TestCase
################################################################
@ -2290,7 +2290,7 @@ class Test_TestCase(TestCase, TestEquality, TestHashing):
def test(self):
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.
# If a test framework needs to use a specialized exception, possibly to
@ -2308,7 +2308,7 @@ class Test_TestCase(TestCase, TestEquality, TestHashing):
failureException = RuntimeError
self.failUnless(Foo('test').failureException is RuntimeError)
self.assertTrue(Foo('test').failureException is RuntimeError)
Foo('test').run(result)
@ -2331,7 +2331,7 @@ class Test_TestCase(TestCase, TestEquality, TestHashing):
failureException = RuntimeError
self.failUnless(Foo('test').failureException is RuntimeError)
self.assertTrue(Foo('test').failureException is RuntimeError)
Foo('test').run(result)
@ -2367,7 +2367,7 @@ class Test_TestCase(TestCase, TestEquality, TestHashing):
def runTest(self):
pass
self.failUnless(isinstance(Foo().id(), str))
self.assertTrue(isinstance(Foo().id(), str))
# "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
@ -2900,23 +2900,23 @@ class Test_TestSkipping(TestCase):
class Test_Assertions(TestCase):
def test_AlmostEqual(self):
self.failUnlessAlmostEqual(1.00000001, 1.0)
self.failIfAlmostEqual(1.0000001, 1.0)
self.assertAlmostEqual(1.00000001, 1.0)
self.assertNotAlmostEqual(1.0000001, 1.0)
self.assertRaises(self.failureException,
self.failUnlessAlmostEqual, 1.0000001, 1.0)
self.assertAlmostEqual, 1.0000001, 1.0)
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.failUnlessAlmostEqual, 1.1, 1.0, places=1)
self.assertAlmostEqual, 1.1, 1.0, places=1)
self.failUnlessAlmostEqual(0, .1+.1j, places=0)
self.failIfAlmostEqual(0, .1+.1j, places=1)
self.assertAlmostEqual(0, .1+.1j, places=0)
self.assertNotAlmostEqual(0, .1+.1j, places=1)
self.assertRaises(self.failureException,
self.failUnlessAlmostEqual, 0, .1+.1j, places=1)
self.assertAlmostEqual, 0, .1+.1j, places=1)
self.assertRaises(self.failureException,
self.failIfAlmostEqual, 0, .1+.1j, places=0)
self.assertNotAlmostEqual, 0, .1+.1j, places=0)
def test_assertRaises(self):
def _raise(e):