diff --git a/Lib/test/test_unittest.py b/Lib/test/test_unittest.py index 85ebf46e749..25fe592947a 100644 --- a/Lib/test/test_unittest.py +++ b/Lib/test/test_unittest.py @@ -2283,7 +2283,6 @@ class Test_TestCase(TestCase, TestEquality, TestHashing): 'Tests shortDescription() for a method with a longer ' 'docstring.')) - def testAddTypeEqualityFunc(self): class SadSnake(object): """Dummy class for test_addTypeEqualityFunc.""" @@ -2658,6 +2657,33 @@ test case self.assertRaisesRegexp, Exception, re.compile('^Expected$'), Stub) + def testSynonymAssertMethodNames(self): + """Test undocumented method name synonyms. + + Please do not use these methods names in your own code. + + This test confirms their continued existence and functionality + in order to avoid breaking existing code. + """ + self.assertNotEquals(3, 5) + self.assertEquals(3, 3) + self.assertAlmostEquals(2.0, 2.0) + self.assertNotAlmostEquals(3.0, 5.0) + self.assert_(True) + + def testPendingDeprecationMethodNames(self): + """Test fail* methods pending deprecation, they will warn in 3.2. + + Do not use these methods. They will go away in 3.3. + """ + self.failIfEqual(3, 5) + self.failUnlessEqual(3, 3) + self.failUnlessAlmostEqual(2.0, 2.0) + self.failIfAlmostEqual(3.0, 5.0) + self.failUnless(True) + self.failUnlessRaises(TypeError, lambda _: 3.14 + u'spam') + self.failIf(False) + class Test_TestSkipping(TestCase): diff --git a/Lib/unittest.py b/Lib/unittest.py index 0f2d2357f93..ba6a0f9ce66 100644 --- a/Lib/unittest.py +++ b/Lib/unittest.py @@ -467,17 +467,17 @@ class TestCase(object): """Fail immediately, with the given message.""" raise self.failureException(msg) - def failIf(self, expr, msg=None): + def assertFalse(self, expr, msg=None): "Fail the test if the expression is true." if expr: raise self.failureException(msg) - def failUnless(self, expr, msg=None): + def assertTrue(self, expr, msg=None): """Fail the test unless the expression is true.""" if not expr: raise self.failureException(msg) - def failUnlessRaises(self, excClass, callableObj=None, *args, **kwargs): + def assertRaises(self, excClass, callableObj=None, *args, **kwargs): """Fail unless an exception of class excClass is thrown by callableObj when invoked with arguments args and keyword arguments kwargs. If a different type of exception is @@ -488,7 +488,7 @@ class TestCase(object): If called with callableObj omitted or None, will return a context object used like this:: - with self.failUnlessRaises(some_error_class): + with self.assertRaises(some_error_class): do_something() """ context = _AssertRaisesContext(excClass, self) @@ -524,21 +524,21 @@ class TestCase(object): if not first == second: raise self.failureException(msg or '%r != %r' % (first, second)) - def failUnlessEqual(self, first, second, msg=None): + def assertEqual(self, first, second, msg=None): """Fail if the two objects are unequal as determined by the '==' operator. """ assertion_func = self._getAssertEqualityFunc(first, second) assertion_func(first, second, msg=msg) - def failIfEqual(self, first, second, msg=None): + def assertNotEqual(self, first, second, msg=None): """Fail if the two objects are equal as determined by the '==' operator. """ if first == second: raise self.failureException(msg or '%r == %r' % (first, second)) - def failUnlessAlmostEqual(self, first, second, places=7, msg=None): + def assertAlmostEqual(self, first, second, places=7, msg=None): """Fail if the two objects are unequal as determined by their difference rounded to the given number of decimal places (default 7) and comparing to zero. @@ -550,7 +550,7 @@ class TestCase(object): raise self.failureException( msg or '%r != %r within %r places' % (first, second, places)) - def failIfAlmostEqual(self, first, second, places=7, msg=None): + def assertNotAlmostEqual(self, first, second, places=7, msg=None): """Fail if the two objects are equal as determined by their difference rounded to the given number of decimal places (default 7) and comparing to zero. @@ -564,19 +564,24 @@ class TestCase(object): # Synonyms for assertion methods - assertEqual = assertEquals = failUnlessEqual + # The plurals are undocumented. Keep them that way to discourage use. + # Do not add more. Do not remove. + # Going through a deprecation cycle on these would annoy many people. + assertEquals = assertEqual + assertNotEquals = assertNotEqual + assertAlmostEquals = assertAlmostEqual + assertNotAlmostEquals = assertNotAlmostEqual + assert_ = assertTrue - assertNotEqual = assertNotEquals = failIfEqual - - assertAlmostEqual = assertAlmostEquals = failUnlessAlmostEqual - - assertNotAlmostEqual = assertNotAlmostEquals = failIfAlmostEqual - - assertRaises = failUnlessRaises - - assert_ = assertTrue = failUnless - - assertFalse = failIf + # These fail* assertion method names are pending deprecation and will + # be a deprecation warning in 3.2; http://bugs.python.org/issue2578 + failUnlessEqual = assertEqual + failIfEqual = assertNotEqual + failUnlessAlmostEqual = assertAlmostEqual + failIfAlmostEqual = assertNotAlmostEqual + failUnless = assertTrue + failUnlessRaises = assertRaises + failIf = assertFalse def assertSequenceEqual(self, seq1, seq2, msg=None, seq_type=None):