diff --git a/Doc/library/2to3.rst b/Doc/library/2to3.rst
--- a/Doc/library/2to3.rst
+++ b/Doc/library/2to3.rst
@@ -142,6 +142,39 @@
    Removes usage of :func:`apply`.  For example ``apply(function, *args,
    **kwargs)`` is converted to ``function(*args, **kwargs)``.
 
+.. 2to3fixer:: asserts
+
+   Replaces deprecated :mod:`unittest` method names with the correct ones.
+
+   ================================  ==========================================
+   From                              To
+   ================================  ==========================================
+   ``failUnlessEqual(a, b)``         :meth:`assertEqual(a, b)
+                                     <unittest.TestCase.assertEqual>`
+   ``assertEquals(a, b)``            :meth:`assertEqual(a, b)
+                                     <unittest.TestCase.assertEqual>`
+   ``failIfEqual(a, b)``             :meth:`assertNotEqual(a, b)
+                                     <unittest.TestCase.assertNotEqual>`
+   ``assertNotEquals(a, b)``         :meth:`assertNotEqual(a, b)
+                                     <unittest.TestCase.assertNotEqual>`
+   ``failUnless(a)``                 :meth:`assertTrue(a)
+                                     <unittest.TestCase.assertTrue>`
+   ``assert_(a)``                    :meth:`assertTrue(a)
+                                     <unittest.TestCase.assertTrue>`
+   ``failIf(a)``                     :meth:`assertFalse(a)
+                                     <unittest.TestCase.assertFalse>`
+   ``failUnlessRaises(exc, cal)``    :meth:`assertRaises(exc, cal)
+                                     <unittest.TestCase.assertRaises>`
+   ``failUnlessAlmostEqual(a, b)``   :meth:`assertAlmostEqual(a, b)
+                                     <unittest.TestCase.assertAlmostEqual>`
+   ``assertAlmostEquals(a, b)``      :meth:`assertAlmostEqual(a, b)
+                                     <unittest.TestCase.assertAlmostEqual>`
+   ``failIfAlmostEqual(a, b)``       :meth:`assertNotAlmostEqual(a, b)
+                                     <unittest.TestCase.assertNotAlmostEqual>`
+   ``assertNotAlmostEquals(a, b)``   :meth:`assertNotAlmostEqual(a, b)
+                                     <unittest.TestCase.assertNotAlmostEqual>`
+   ================================  ==========================================
+
 .. 2to3fixer:: basestring
 
    Converts :class:`basestring` to :class:`str`.
diff --git a/Lib/lib2to3/fixes/fix_asserts.py b/Lib/lib2to3/fixes/fix_asserts.py
new file mode 100644
--- /dev/null
+++ b/Lib/lib2to3/fixes/fix_asserts.py
@@ -0,0 +1,34 @@
+"""Fixer that replaces deprecated unittest method names."""
+
+# Author: Ezio Melotti
+
+from ..fixer_base import BaseFix
+from ..fixer_util import Name
+
+NAMES = dict(
+    assert_="assertTrue",
+    assertEquals="assertEqual",
+    assertNotEquals="assertNotEqual",
+    assertAlmostEquals="assertAlmostEqual",
+    assertNotAlmostEquals="assertNotAlmostEqual",
+    assertRegexpMatches="assertRegex",
+    assertRaisesRegexp="assertRaisesRegex",
+    failUnlessEqual="assertEqual",
+    failIfEqual="assertNotEqual",
+    failUnlessAlmostEqual="assertAlmostEqual",
+    failIfAlmostEqual="assertNotAlmostEqual",
+    failUnless="assertTrue",
+    failUnlessRaises="assertRaises",
+    failIf="assertFalse",
+)
+
+
+class FixAsserts(BaseFix):
+
+    PATTERN = """
+              power< any+ trailer< '.' meth=(%s)> any* >
+              """ % '|'.join(map(repr, NAMES))
+
+    def transform(self, node, results):
+        name = results["meth"][0]
+        name.replace(Name(NAMES[str(name)], prefix=name.prefix))
diff --git a/Lib/lib2to3/tests/test_fixers.py b/Lib/lib2to3/tests/test_fixers.py
--- a/Lib/lib2to3/tests/test_fixers.py
+++ b/Lib/lib2to3/tests/test_fixers.py
@@ -4635,3 +4635,53 @@
     def test_unchanged(self):
         s = """f(sys.exitfunc)"""
         self.unchanged(s)
+
+
+class Test_asserts(FixerTestCase):
+
+    fixer = "asserts"
+
+    def test_deprecated_names(self):
+        tests = [
+            ('self.assert_(True)', 'self.assertTrue(True)'),
+            ('self.assertEquals(2, 2)', 'self.assertEqual(2, 2)'),
+            ('self.assertNotEquals(2, 3)', 'self.assertNotEqual(2, 3)'),
+            ('self.assertAlmostEquals(2, 3)', 'self.assertAlmostEqual(2, 3)'),
+            ('self.assertNotAlmostEquals(2, 8)', 'self.assertNotAlmostEqual(2, 8)'),
+            ('self.failUnlessEqual(2, 2)', 'self.assertEqual(2, 2)'),
+            ('self.failIfEqual(2, 3)', 'self.assertNotEqual(2, 3)'),
+            ('self.failUnlessAlmostEqual(2, 3)', 'self.assertAlmostEqual(2, 3)'),
+            ('self.failIfAlmostEqual(2, 8)', 'self.assertNotAlmostEqual(2, 8)'),
+            ('self.failUnless(True)', 'self.assertTrue(True)'),
+            ('self.failUnlessRaises(foo)', 'self.assertRaises(foo)'),
+            ('self.failIf(False)', 'self.assertFalse(False)'),
+        ]
+        for b, a in tests:
+            self.check(b, a)
+
+    def test_variants(self):
+        b = 'eq = self.assertEquals'
+        a = 'eq = self.assertEqual'
+        self.check(b, a)
+        b = 'self.assertEquals(2, 3, msg="fail")'
+        a = 'self.assertEqual(2, 3, msg="fail")'
+        self.check(b, a)
+        b = 'self.assertEquals(2, 3, msg="fail") # foo'
+        a = 'self.assertEqual(2, 3, msg="fail") # foo'
+        self.check(b, a)
+        b = 'self.assertEquals (2, 3)'
+        a = 'self.assertEqual (2, 3)'
+        self.check(b, a)
+        b = '  self.assertEquals (2, 3)'
+        a = '  self.assertEqual (2, 3)'
+        self.check(b, a)
+        b = 'with self.failUnlessRaises(Explosion): explode()'
+        a = 'with self.assertRaises(Explosion): explode()'
+        self.check(b, a)
+        b = 'with self.failUnlessRaises(Explosion) as cm: explode()'
+        a = 'with self.assertRaises(Explosion) as cm: explode()'
+        self.check(b, a)
+
+    def test_unchanged(self):
+        self.unchanged('self.assertEqualsOnSaturday')
+        self.unchanged('self.assertEqualsOnSaturday(3, 5)')