Replace deprecated alias assertEquals() with assertEqual().

tests/test_smart_list.py

@@ -39,80 +39,80 @@ class TestSmartList(unittest.TestCase):
         list1 = builder([0, 1, 2, 3, "one", "two"])
         list2 = builder(list(range(10)))
 
-        self.assertEquals(1, list1[1])
-        self.assertEquals("one", list1[-2])
-        self.assertEquals([2, 3], list1[2:4])
+        self.assertEqual(1, list1[1])
+        self.assertEqual("one", list1[-2])
+        self.assertEqual([2, 3], list1[2:4])
         self.assertRaises(IndexError, lambda: list1[6])
         self.assertRaises(IndexError, lambda: list1[-7])
 
-        self.assertEquals([0, 1, 2], list1[:3])
-        self.assertEquals([0, 1, 2, 3, "one", "two"], list1[:])
-        self.assertEquals([3, "one", "two"], list1[3:])
-        self.assertEquals(["one", "two"], list1[-2:])
-        self.assertEquals([0, 1], list1[:-4])
-        self.assertEquals([], list1[6:])
-        self.assertEquals([], list1[4:2])
-
-        self.assertEquals([0, 2, "one"], list1[0:5:2])
-        self.assertEquals([0, 2], list1[0:-3:2])
-        self.assertEquals([0, 1, 2, 3, "one", "two"], list1[::])
-        self.assertEquals([2, 3, "one", "two"], list1[2::])
-        self.assertEquals([0, 1, 2, 3], list1[:4:])
-        self.assertEquals([2, 3], list1[2:4:])
-        self.assertEquals([0, 2, 4, 6, 8], list2[::2])
-        self.assertEquals([2, 5, 8], list2[2::3])
-        self.assertEquals([0, 3], list2[:6:3])
-        self.assertEquals([2, 5, 8], list2[-8:9:3])
-        self.assertEquals([], list2[100000:1000:-100])
+        self.assertEqual([0, 1, 2], list1[:3])
+        self.assertEqual([0, 1, 2, 3, "one", "two"], list1[:])
+        self.assertEqual([3, "one", "two"], list1[3:])
+        self.assertEqual(["one", "two"], list1[-2:])
+        self.assertEqual([0, 1], list1[:-4])
+        self.assertEqual([], list1[6:])
+        self.assertEqual([], list1[4:2])
+
+        self.assertEqual([0, 2, "one"], list1[0:5:2])
+        self.assertEqual([0, 2], list1[0:-3:2])
+        self.assertEqual([0, 1, 2, 3, "one", "two"], list1[::])
+        self.assertEqual([2, 3, "one", "two"], list1[2::])
+        self.assertEqual([0, 1, 2, 3], list1[:4:])
+        self.assertEqual([2, 3], list1[2:4:])
+        self.assertEqual([0, 2, 4, 6, 8], list2[::2])
+        self.assertEqual([2, 5, 8], list2[2::3])
+        self.assertEqual([0, 3], list2[:6:3])
+        self.assertEqual([2, 5, 8], list2[-8:9:3])
+        self.assertEqual([], list2[100000:1000:-100])
 
         list1[3] = 100
-        self.assertEquals(100, list1[3])
+        self.assertEqual(100, list1[3])
         list1[-3] = 101
-        self.assertEquals([0, 1, 2, 101, "one", "two"], list1)
+        self.assertEqual([0, 1, 2, 101, "one", "two"], list1)
         list1[5:] = [6, 7, 8]
-        self.assertEquals([6, 7, 8], list1[5:])
-        self.assertEquals([0, 1, 2, 101, "one", 6, 7, 8], list1)
+        self.assertEqual([6, 7, 8], list1[5:])
+        self.assertEqual([0, 1, 2, 101, "one", 6, 7, 8], list1)
         list1[2:4] = [-1, -2, -3, -4, -5]
-        self.assertEquals([0, 1, -1, -2, -3, -4, -5, "one", 6, 7, 8], list1)
+        self.assertEqual([0, 1, -1, -2, -3, -4, -5, "one", 6, 7, 8], list1)
         list1[0:-3] = [99]
-        self.assertEquals([99, 6, 7, 8], list1)
+        self.assertEqual([99, 6, 7, 8], list1)
         list2[0:6:2] = [100, 102, 104]
-        self.assertEquals([100, 1, 102, 3, 104, 5, 6, 7, 8, 9], list2)
+        self.assertEqual([100, 1, 102, 3, 104, 5, 6, 7, 8, 9], list2)
         list2[::3] = [200, 203, 206, 209]
-        self.assertEquals([200, 1, 102, 203, 104, 5, 206, 7, 8, 209], list2)
+        self.assertEqual([200, 1, 102, 203, 104, 5, 206, 7, 8, 209], list2)
         list2[::] = range(7)
-        self.assertEquals([0, 1, 2, 3, 4, 5, 6], list2)
+        self.assertEqual([0, 1, 2, 3, 4, 5, 6], list2)
         self.assertRaises(ValueError, assign, list2, 0, 5, 2,
                           [100, 102, 104, 106])
 
         del list2[2]
-        self.assertEquals([0, 1, 3, 4, 5, 6], list2)
+        self.assertEqual([0, 1, 3, 4, 5, 6], list2)
         del list2[-3]
-        self.assertEquals([0, 1, 3, 5, 6], list2)
+        self.assertEqual([0, 1, 3, 5, 6], list2)
         self.assertRaises(IndexError, delete, list2, 100)
         self.assertRaises(IndexError, delete, list2, -6)
         list2[:] = range(10)
         del list2[3:6]
-        self.assertEquals([0, 1, 2, 6, 7, 8, 9], list2)
+        self.assertEqual([0, 1, 2, 6, 7, 8, 9], list2)
         del list2[-2:]
-        self.assertEquals([0, 1, 2, 6, 7], list2)
+        self.assertEqual([0, 1, 2, 6, 7], list2)
         del list2[:2]
-        self.assertEquals([2, 6, 7], list2)
+        self.assertEqual([2, 6, 7], list2)
         list2[:] = range(10)
         del list2[2:8:2]
-        self.assertEquals([0, 1, 3, 5, 7, 8, 9], list2)
+        self.assertEqual([0, 1, 3, 5, 7, 8, 9], list2)
 
     def _test_add_radd_iadd(self, builder):
         """Run tests on __r/i/add__ of a list built with *builder*."""
         list1 = builder(range(5))
         list2 = builder(range(5, 10))
-        self.assertEquals([0, 1, 2, 3, 4, 5, 6], list1 + [5, 6])
-        self.assertEquals([0, 1, 2, 3, 4], list1)
-        self.assertEquals(list(range(10)), list1 + list2)
-        self.assertEquals([-2, -1, 0, 1, 2, 3, 4], [-2, -1] + list1)
-        self.assertEquals([0, 1, 2, 3, 4], list1)
+        self.assertEqual([0, 1, 2, 3, 4, 5, 6], list1 + [5, 6])
+        self.assertEqual([0, 1, 2, 3, 4], list1)
+        self.assertEqual(list(range(10)), list1 + list2)
+        self.assertEqual([-2, -1, 0, 1, 2, 3, 4], [-2, -1] + list1)
+        self.assertEqual([0, 1, 2, 3, 4], list1)
         list1 += ["foo", "bar", "baz"]
-        self.assertEquals([0, 1, 2, 3, 4, "foo", "bar", "baz"], list1)
+        self.assertEqual([0, 1, 2, 3, 4, "foo", "bar", "baz"], list1)
 
     def _test_other_magic_methods(self, builder):
         """Run tests on other magic methods of a list built with *builder*."""
@@ -122,13 +122,13 @@ class TestSmartList(unittest.TestCase):
         list4 = builder([0, 1, 2])
 
         if py3k:
-            self.assertEquals("[0, 1, 2, 3, 'one', 'two']", str(list1))
-            self.assertEquals(b"[0, 1, 2, 3, 'one', 'two']", bytes(list1))
-            self.assertEquals("[0, 1, 2, 3, 'one', 'two']", repr(list1))
+            self.assertEqual("[0, 1, 2, 3, 'one', 'two']", str(list1))
+            self.assertEqual(b"[0, 1, 2, 3, 'one', 'two']", bytes(list1))
+            self.assertEqual("[0, 1, 2, 3, 'one', 'two']", repr(list1))
         else:
-            self.assertEquals("[0, 1, 2, 3, u'one', u'two']", unicode(list1))
-            self.assertEquals(b"[0, 1, 2, 3, u'one', u'two']", str(list1))
-            self.assertEquals(b"[0, 1, 2, 3, u'one', u'two']", repr(list1))
+            self.assertEqual("[0, 1, 2, 3, u'one', u'two']", unicode(list1))
+            self.assertEqual(b"[0, 1, 2, 3, u'one', u'two']", str(list1))
+            self.assertEqual(b"[0, 1, 2, 3, u'one', u'two']", repr(list1))
 
         self.assertTrue(list1 < list3)
         self.assertTrue(list1 <= list3)
@@ -164,42 +164,42 @@ class TestSmartList(unittest.TestCase):
         self.assertTrue(bool(list1))
         self.assertFalse(bool(list2))
 
-        self.assertEquals(6, len(list1))
-        self.assertEquals(0, len(list2))
+        self.assertEqual(6, len(list1))
+        self.assertEqual(0, len(list2))
 
         out = []
         for obj in list1:
             out.append(obj)
-        self.assertEquals([0, 1, 2, 3, "one", "two"], out)
+        self.assertEqual([0, 1, 2, 3, "one", "two"], out)
 
         out = []
         for ch in list2:
             out.append(ch)
-        self.assertEquals([], out)
+        self.assertEqual([], out)
 
         gen1 = iter(list1)
         out = []
         for i in range(len(list1)):
             out.append(gen1.next())
         self.assertRaises(StopIteration, gen1.next)
-        self.assertEquals([0, 1, 2, 3, "one", "two"], out)
+        self.assertEqual([0, 1, 2, 3, "one", "two"], out)
         gen2 = iter(list2)
         self.assertRaises(StopIteration, gen2.next)
 
-        self.assertEquals(["two", "one", 3, 2, 1, 0], list(reversed(list1)))
-        self.assertEquals([], list(reversed(list2)))
+        self.assertEqual(["two", "one", 3, 2, 1, 0], list(reversed(list1)))
+        self.assertEqual([], list(reversed(list2)))
 
         self.assertTrue("one" in list1)
         self.assertTrue(3 in list1)
         self.assertFalse(10 in list1)
         self.assertFalse(0 in list2)
 
-        self.assertEquals([], list2 * 5)
-        self.assertEquals([], 5 * list2)
-        self.assertEquals([0, 1, 2, 0, 1, 2, 0, 1, 2], list4 * 3)
-        self.assertEquals([0, 1, 2, 0, 1, 2, 0, 1, 2], 3 * list4)
+        self.assertEqual([], list2 * 5)
+        self.assertEqual([], 5 * list2)
+        self.assertEqual([0, 1, 2, 0, 1, 2, 0, 1, 2], list4 * 3)
+        self.assertEqual([0, 1, 2, 0, 1, 2, 0, 1, 2], 3 * list4)
         list4 *= 2
-        self.assertEquals([0, 1, 2, 0, 1, 2], list4)
+        self.assertEqual([0, 1, 2, 0, 1, 2], list4)
 
     def _test_list_methods(self, builder):
         """Run tests on the public methods of a list built with *builder*."""
@@ -210,60 +210,60 @@ class TestSmartList(unittest.TestCase):
         list1.append(5)
         list1.append(1)
         list1.append(2)
-        self.assertEquals([0, 1, 2, 3, 4, 5, 1, 2], list1)
+        self.assertEqual([0, 1, 2, 3, 4, 5, 1, 2], list1)
 
-        self.assertEquals(0, list1.count(6))
-        self.assertEquals(2, list1.count(1))
+        self.assertEqual(0, list1.count(6))
+        self.assertEqual(2, list1.count(1))
 
         list1.extend(range(5, 8))
-        self.assertEquals([0, 1, 2, 3, 4, 5, 1, 2, 5, 6, 7], list1)
+        self.assertEqual([0, 1, 2, 3, 4, 5, 1, 2, 5, 6, 7], list1)
 
-        self.assertEquals(1, list1.index(1))
-        self.assertEquals(6, list1.index(1, 3))
-        self.assertEquals(6, list1.index(1, 3, 7))
+        self.assertEqual(1, list1.index(1))
+        self.assertEqual(6, list1.index(1, 3))
+        self.assertEqual(6, list1.index(1, 3, 7))
         self.assertRaises(ValueError, list1.index, 1, 3, 5)
 
         list1.insert(0, -1)
-        self.assertEquals([-1, 0, 1, 2, 3, 4, 5, 1, 2, 5, 6, 7], list1)
+        self.assertEqual([-1, 0, 1, 2, 3, 4, 5, 1, 2, 5, 6, 7], list1)
         list1.insert(-1, 6.5)
-        self.assertEquals([-1, 0, 1, 2, 3, 4, 5, 1, 2, 5, 6, 6.5, 7], list1)
+        self.assertEqual([-1, 0, 1, 2, 3, 4, 5, 1, 2, 5, 6, 6.5, 7], list1)
         list1.insert(13, 8)
-        self.assertEquals([-1, 0, 1, 2, 3, 4, 5, 1, 2, 5, 6, 6.5, 7, 8], list1)
-
-        self.assertEquals(8, list1.pop())
-        self.assertEquals(7, list1.pop())
-        self.assertEquals([-1, 0, 1, 2, 3, 4, 5, 1, 2, 5, 6, 6.5], list1)
-        self.assertEquals(-1, list1.pop(0))
-        self.assertEquals(5, list1.pop(5))
-        self.assertEquals(6.5, list1.pop(-1))
-        self.assertEquals([0, 1, 2, 3, 4, 1, 2, 5, 6], list1)
-        self.assertEquals("foo", list2.pop())
+        self.assertEqual([-1, 0, 1, 2, 3, 4, 5, 1, 2, 5, 6, 6.5, 7, 8], list1)
+
+        self.assertEqual(8, list1.pop())
+        self.assertEqual(7, list1.pop())
+        self.assertEqual([-1, 0, 1, 2, 3, 4, 5, 1, 2, 5, 6, 6.5], list1)
+        self.assertEqual(-1, list1.pop(0))
+        self.assertEqual(5, list1.pop(5))
+        self.assertEqual(6.5, list1.pop(-1))
+        self.assertEqual([0, 1, 2, 3, 4, 1, 2, 5, 6], list1)
+        self.assertEqual("foo", list2.pop())
         self.assertRaises(IndexError, list2.pop)
-        self.assertEquals([], list2)
+        self.assertEqual([], list2)
 
         list1.remove(6)
-        self.assertEquals([0, 1, 2, 3, 4, 1, 2, 5], list1)
+        self.assertEqual([0, 1, 2, 3, 4, 1, 2, 5], list1)
         list1.remove(1)
-        self.assertEquals([0, 2, 3, 4, 1, 2, 5], list1)
+        self.assertEqual([0, 2, 3, 4, 1, 2, 5], list1)
         list1.remove(1)
-        self.assertEquals([0, 2, 3, 4, 2, 5], list1)
+        self.assertEqual([0, 2, 3, 4, 2, 5], list1)
         self.assertRaises(ValueError, list1.remove, 1)
 
         list1.reverse()
-        self.assertEquals([5, 2, 4, 3, 2, 0], list1)
+        self.assertEqual([5, 2, 4, 3, 2, 0], list1)
 
         list1.sort()
-        self.assertEquals([0, 2, 2, 3, 4, 5], list1)
+        self.assertEqual([0, 2, 2, 3, 4, 5], list1)
         list1.sort(reverse=True)
-        self.assertEquals([5, 4, 3, 2, 2, 0], list1)
+        self.assertEqual([5, 4, 3, 2, 2, 0], list1)
         list1.sort(cmp=lambda x, y: abs(3 - x) - abs(3 - y))  # Distance from 3
-        self.assertEquals([3, 4, 2, 2, 5, 0], list1)
+        self.assertEqual([3, 4, 2, 2, 5, 0], list1)
         list1.sort(cmp=lambda x, y: abs(3 - x) - abs(3 - y), reverse=True)
-        self.assertEquals([0, 5, 4, 2, 2, 3], list1)
+        self.assertEqual([0, 5, 4, 2, 2, 3], list1)
         list3.sort(key=lambda i: i[1])
-        self.assertEquals([("d", 2), ("c", 3), ("a", 5), ("b", 8)], list3)
+        self.assertEqual([("d", 2), ("c", 3), ("a", 5), ("b", 8)], list3)
         list3.sort(key=lambda i: i[1], reverse=True)
-        self.assertEquals([("b", 8), ("a", 5), ("c", 3), ("d", 2)], list3)
+        self.assertEqual([("b", 8), ("a", 5), ("c", 3), ("d", 2)], list3)
 
     def test_docs(self):
         """make sure the methods of SmartList/_ListProxy have docstrings"""
@@ -273,18 +273,18 @@ class TestSmartList(unittest.TestCase):
             expected = getattr(list, meth).__doc__
             smartlist_doc = getattr(SmartList, meth).__doc__
             listproxy_doc = getattr(_ListProxy, meth).__doc__
-            self.assertEquals(expected, smartlist_doc)
-            self.assertEquals(expected, listproxy_doc)
+            self.assertEqual(expected, smartlist_doc)
+            self.assertEqual(expected, listproxy_doc)
 
     def test_doctest(self):
         """make sure the test embedded in SmartList's docstring passes"""
         parent = SmartList([0, 1, 2, 3])
-        self.assertEquals([0, 1, 2, 3], parent)
+        self.assertEqual([0, 1, 2, 3], parent)
         child = parent[2:]
-        self.assertEquals([2, 3], child)
+        self.assertEqual([2, 3], child)
         child.append(4)
-        self.assertEquals([2, 3, 4], child)
-        self.assertEquals([0, 1, 2, 3, 4], parent)
+        self.assertEqual([2, 3, 4], child)
+        self.assertEqual([0, 1, 2, 3, 4], parent)
 
     def test_parent_get_set_del(self):
         """make sure SmartList's getitem/setitem/delitem work"""
@@ -343,46 +343,46 @@ class TestSmartList(unittest.TestCase):
         parent.append(6)
         child1.append(7)
         child2.append(4.5)
-        self.assertEquals([0, 1, 2, 3, 4, 4.5, 5, 6, 7], parent)
-        self.assertEquals([2, 3, 4, 4.5, 5, 6, 7], child1)
-        self.assertEquals([2, 3, 4, 4.5], child2)
+        self.assertEqual([0, 1, 2, 3, 4, 4.5, 5, 6, 7], parent)
+        self.assertEqual([2, 3, 4, 4.5, 5, 6, 7], child1)
+        self.assertEqual([2, 3, 4, 4.5], child2)
 
         parent.insert(0, -1)
         parent.insert(4, 2.5)
         parent.insert(10, 6.5)
-        self.assertEquals([-1, 0, 1, 2, 2.5, 3, 4, 4.5, 5, 6, 6.5, 7], parent)
-        self.assertEquals([2, 2.5, 3, 4, 4.5, 5, 6, 6.5, 7], child1)
-        self.assertEquals([2, 2.5, 3, 4, 4.5], child2)
+        self.assertEqual([-1, 0, 1, 2, 2.5, 3, 4, 4.5, 5, 6, 6.5, 7], parent)
+        self.assertEqual([2, 2.5, 3, 4, 4.5, 5, 6, 6.5, 7], child1)
+        self.assertEqual([2, 2.5, 3, 4, 4.5], child2)
 
-        self.assertEquals(7, parent.pop())
-        self.assertEquals(6.5, child1.pop())
-        self.assertEquals(4.5, child2.pop())
-        self.assertEquals([-1, 0, 1, 2, 2.5, 3, 4, 5, 6], parent)
-        self.assertEquals([2, 2.5, 3, 4, 5, 6], child1)
-        self.assertEquals([2, 2.5, 3, 4], child2)
+        self.assertEqual(7, parent.pop())
+        self.assertEqual(6.5, child1.pop())
+        self.assertEqual(4.5, child2.pop())
+        self.assertEqual([-1, 0, 1, 2, 2.5, 3, 4, 5, 6], parent)
+        self.assertEqual([2, 2.5, 3, 4, 5, 6], child1)
+        self.assertEqual([2, 2.5, 3, 4], child2)
 
         parent.remove(-1)
         child1.remove(2.5)
-        self.assertEquals([0, 1, 2, 3, 4, 5, 6], parent)
-        self.assertEquals([2, 3, 4, 5, 6], child1)
-        self.assertEquals([2, 3, 4], child2)
+        self.assertEqual([0, 1, 2, 3, 4, 5, 6], parent)
+        self.assertEqual([2, 3, 4, 5, 6], child1)
+        self.assertEqual([2, 3, 4], child2)
 
-        self.assertEquals(0, parent.pop(0))
-        self.assertEquals([1, 2, 3, 4, 5, 6], parent)
-        self.assertEquals([2, 3, 4, 5, 6], child1)
-        self.assertEquals([2, 3, 4], child2)
+        self.assertEqual(0, parent.pop(0))
+        self.assertEqual([1, 2, 3, 4, 5, 6], parent)
+        self.assertEqual([2, 3, 4, 5, 6], child1)
+        self.assertEqual([2, 3, 4], child2)
 
         child2.reverse()
-        self.assertEquals([1, 4, 3, 2, 5, 6], parent)
-        self.assertEquals([4, 3, 2, 5, 6], child1)
-        self.assertEquals([4, 3, 2], child2)
+        self.assertEqual([1, 4, 3, 2, 5, 6], parent)
+        self.assertEqual([4, 3, 2, 5, 6], child1)
+        self.assertEqual([4, 3, 2], child2)
 
         parent.extend([7, 8])
         child1.extend([8.1, 8.2])
         child2.extend([1.9, 1.8])
-        self.assertEquals([1, 4, 3, 2, 1.9, 1.8, 5, 6, 7, 8, 8.1, 8.2], parent)
-        self.assertEquals([4, 3, 2, 1.9, 1.8, 5, 6, 7, 8, 8.1, 8.2], child1)
-        self.assertEquals([4, 3, 2, 1.9, 1.8], child2)
+        self.assertEqual([1, 4, 3, 2, 1.9, 1.8, 5, 6, 7, 8, 8.1, 8.2], parent)
+        self.assertEqual([4, 3, 2, 1.9, 1.8, 5, 6, 7, 8, 8.1, 8.2], child1)
+        self.assertEqual([4, 3, 2, 1.9, 1.8], child2)
 
 if __name__ == "__main__":
     unittest.main(verbosity=2)

tests/test_string_mixin.py

@@ -56,17 +56,17 @@ class TestStringMixIn(unittest.TestCase):
         for meth in methods:
             expected = getattr(str, meth).__doc__
             actual = getattr(StringMixIn, meth).__doc__
-            self.assertEquals(expected, actual)
+            self.assertEqual(expected, actual)
 
     def test_types(self):
         """make sure StringMixIns convert to different types correctly"""
         fstr = _FakeString("fake string")
-        self.assertEquals(str(fstr), "fake string")
-        self.assertEquals(bytes(fstr), b"fake string")
+        self.assertEqual(str(fstr), "fake string")
+        self.assertEqual(bytes(fstr), b"fake string")
         if py3k:
-            self.assertEquals(repr(fstr), "'fake string'")
+            self.assertEqual(repr(fstr), "'fake string'")
         else:
-            self.assertEquals(repr(fstr), b"u'fake string'")
+            self.assertEqual(repr(fstr), b"u'fake string'")
 
         self.assertIsInstance(str(fstr), str)
         self.assertIsInstance(bytes(fstr), bytes)
@@ -119,18 +119,18 @@ class TestStringMixIn(unittest.TestCase):
 
         self.assertTrue(str1)
         self.assertFalse(str2)
-        self.assertEquals(11, len(str1))
-        self.assertEquals(0, len(str2))
+        self.assertEqual(11, len(str1))
+        self.assertEqual(0, len(str2))
 
         out = []
         for ch in str1:
             out.append(ch)
-        self.assertEquals(expected, out)
+        self.assertEqual(expected, out)
 
         out = []
         for ch in str2:
             out.append(ch)
-        self.assertEquals([], out)
+        self.assertEqual([], out)
 
         gen1 = iter(str1)
         gen2 = iter(str2)
@@ -141,16 +141,16 @@ class TestStringMixIn(unittest.TestCase):
         for i in range(len(str1)):
             out.append(gen1.next())
         self.assertRaises(StopIteration, gen1.next)
-        self.assertEquals(expected, out)
+        self.assertEqual(expected, out)
         self.assertRaises(StopIteration, gen2.next)
 
-        self.assertEquals("gnirts ekaf", "".join(list(reversed(str1))))
-        self.assertEquals([], list(reversed(str2)))
+        self.assertEqual("gnirts ekaf", "".join(list(reversed(str1))))
+        self.assertEqual([], list(reversed(str2)))
 
-        self.assertEquals("f", str1[0])
-        self.assertEquals(" ", str1[4])
-        self.assertEquals("g", str1[10])
-        self.assertEquals("n", str1[-2])
+        self.assertEqual("f", str1[0])
+        self.assertEqual(" ", str1[4])
+        self.assertEqual("g", str1[10])
+        self.assertEqual("n", str1[-2])
         self.assertRaises(IndexError, lambda: str1[11])
         self.assertRaises(IndexError, lambda: str2[0])
 
@@ -165,75 +165,75 @@ class TestStringMixIn(unittest.TestCase):
     def test_other_methods(self):
         """test the remaining non-magic methods of StringMixIn"""
         str1 = _FakeString("fake string")
-        self.assertEquals("Fake string", str1.capitalize())
+        self.assertEqual("Fake string", str1.capitalize())
 
-        self.assertEquals("  fake string  ", str1.center(15))
-        self.assertEquals("  fake string   ", str1.center(16))
-        self.assertEquals("qqfake stringqq", str1.center(15, "q"))
+        self.assertEqual("  fake string  ", str1.center(15))
+        self.assertEqual("  fake string   ", str1.center(16))
+        self.assertEqual("qqfake stringqq", str1.center(15, "q"))
 
-        self.assertEquals(1, str1.count("e"))
-        self.assertEquals(0, str1.count("z"))
-        self.assertEquals(1, str1.count("r", 7))
-        self.assertEquals(0, str1.count("r", 8))
-        self.assertEquals(1, str1.count("r", 5, 9))
-        self.assertEquals(0, str1.count("r", 5, 7))
+        self.assertEqual(1, str1.count("e"))
+        self.assertEqual(0, str1.count("z"))
+        self.assertEqual(1, str1.count("r", 7))
+        self.assertEqual(0, str1.count("r", 8))
+        self.assertEqual(1, str1.count("r", 5, 9))
+        self.assertEqual(0, str1.count("r", 5, 7))
 
         if not py3k:
             str2 = _FakeString("fo")
-            self.assertEquals(str1, str1.decode())
+            self.assertEqual(str1, str1.decode())
             actual = _FakeString("\\U00010332\\U0001033f\\U00010344")
-            self.assertEquals("𐌲𐌿𐍄", actual.decode("unicode_escape"))
+            self.assertEqual("𐌲𐌿𐍄", actual.decode("unicode_escape"))
             self.assertRaises(UnicodeError, str2.decode, "punycode")
-            self.assertEquals("", str2.decode("punycode", "ignore"))
+            self.assertEqual("", str2.decode("punycode", "ignore"))
 
         str3 = _FakeString("𐌲𐌿𐍄")
-        self.assertEquals(b"fake string", str1.encode())
-        self.assertEquals(b"\xF0\x90\x8C\xB2\xF0\x90\x8C\xBF\xF0\x90\x8D\x84",
+        self.assertEqual(b"fake string", str1.encode())
+        self.assertEqual(b"\xF0\x90\x8C\xB2\xF0\x90\x8C\xBF\xF0\x90\x8D\x84",
                           str3.encode("utf8"))
-        self.assertEquals(b"\xF0\x90\x8C\xB2\xF0\x90\x8C\xBF\xF0\x90\x8D\x84",
+        self.assertEqual(b"\xF0\x90\x8C\xB2\xF0\x90\x8C\xBF\xF0\x90\x8D\x84",
                           str3.encode(encoding="utf8"))
         self.assertRaises(UnicodeEncodeError, str3.encode)
         self.assertRaises(UnicodeEncodeError, str3.encode, "ascii")
         self.assertRaises(UnicodeEncodeError, str3.encode, "ascii", "strict")
         self.assertRaises(UnicodeEncodeError, str3.encode, errors="strict")
-        self.assertEquals("", str3.encode("ascii", "ignore"))
-        self.assertEquals("", str3.encode(errors="ignore"))
+        self.assertEqual("", str3.encode("ascii", "ignore"))
+        self.assertEqual("", str3.encode(errors="ignore"))
 
         self.assertTrue(str1.endswith("ing"))
         self.assertFalse(str1.endswith("ingh"))
 
         str4 = _FakeString("\tfoobar")
-        self.assertEquals("fake string", str1)
-        self.assertEquals("        foobar", str4.expandtabs())
-        self.assertEquals("    foobar", str4.expandtabs(4))
+        self.assertEqual("fake string", str1)
+        self.assertEqual("        foobar", str4.expandtabs())
+        self.assertEqual("    foobar", str4.expandtabs(4))
 
-        self.assertEquals(3, str1.find("e"))
-        self.assertEquals(-1, str1.find("z"))
-        self.assertEquals(7, str1.find("r", 7))
-        self.assertEquals(-1, str1.find("r", 8))
-        self.assertEquals(7, str1.find("r", 5, 9))
-        self.assertEquals(-1, str1.find("r", 5, 7))
+        self.assertEqual(3, str1.find("e"))
+        self.assertEqual(-1, str1.find("z"))
+        self.assertEqual(7, str1.find("r", 7))
+        self.assertEqual(-1, str1.find("r", 8))
+        self.assertEqual(7, str1.find("r", 5, 9))
+        self.assertEqual(-1, str1.find("r", 5, 7))
 
         str5 = _FakeString("foo{0}baz")
         str6 = _FakeString("foo{abc}baz")
         str7 = _FakeString("foo{0}{abc}buzz")
         str8 = _FakeString("{0}{1}")
-        self.assertEquals("fake string", str1.format())
-        self.assertEquals("foobarbaz", str5.format("bar"))
-        self.assertEquals("foobarbaz", str6.format(abc="bar"))
-        self.assertEquals("foobarbazbuzz", str7.format("bar", abc="baz"))
+        self.assertEqual("fake string", str1.format())
+        self.assertEqual("foobarbaz", str5.format("bar"))
+        self.assertEqual("foobarbaz", str6.format(abc="bar"))
+        self.assertEqual("foobarbazbuzz", str7.format("bar", abc="baz"))
         self.assertRaises(IndexError, str8.format, "abc")
 
         if py3k:
-            self.assertEquals("fake string", str1.format_map({}))
-            self.assertEquals("foobarbaz", str6.format_map({"abc": "bar"}))
+            self.assertEqual("fake string", str1.format_map({}))
+            self.assertEqual("foobarbaz", str6.format_map({"abc": "bar"}))
             self.assertRaises(ValueError, str5.format_map, {0: "abc"})
 
-        self.assertEquals(3, str1.index("e"))
+        self.assertEqual(3, str1.index("e"))
         self.assertRaises(ValueError, str1.index, "z")
-        self.assertEquals(7, str1.index("r", 7))
+        self.assertEqual(7, str1.index("r", 7))
         self.assertRaises(ValueError, str1.index, "r", 8)
-        self.assertEquals(7, str1.index("r", 5, 9))
+        self.assertEqual(7, str1.index("r", 5, 9))
         self.assertRaises(ValueError, str1.index, "r", 5, 7)
 
         str9 = _FakeString("foobar")
@@ -303,120 +303,120 @@ class TestStringMixIn(unittest.TestCase):
         self.assertFalse(str15.isupper())
         self.assertTrue(str21.isupper())
 
-        self.assertEquals("foobar", str15.join(["foo", "bar"]))
-        self.assertEquals("foo123bar123baz", str12.join(("foo", "bar", "baz")))
+        self.assertEqual("foobar", str15.join(["foo", "bar"]))
+        self.assertEqual("foo123bar123baz", str12.join(("foo", "bar", "baz")))
 
-        self.assertEquals("fake string    ", str1.ljust(15))
-        self.assertEquals("fake string     ", str1.ljust(16))
-        self.assertEquals("fake stringqqqq", str1.ljust(15, "q"))
+        self.assertEqual("fake string    ", str1.ljust(15))
+        self.assertEqual("fake string     ", str1.ljust(16))
+        self.assertEqual("fake stringqqqq", str1.ljust(15, "q"))
 
         str22 = _FakeString("ß")
-        self.assertEquals("", str15.lower())
-        self.assertEquals("foobar", str16.lower())
-        self.assertEquals("ß", str22.lower())
+        self.assertEqual("", str15.lower())
+        self.assertEqual("foobar", str16.lower())
+        self.assertEqual("ß", str22.lower())
         if py3k:
-            self.assertEquals("", str15.casefold())
-            self.assertEquals("foobar", str16.casefold())
-            self.assertEquals("ss", str22.casefold())
+            self.assertEqual("", str15.casefold())
+            self.assertEqual("foobar", str16.casefold())
+            self.assertEqual("ss", str22.casefold())
 
         str23 = _FakeString("  fake string  ")
-        self.assertEquals("fake string", str1.lstrip())
-        self.assertEquals("fake string  ", str23.lstrip())
-        self.assertEquals("ke string", str1.lstrip("abcdef"))
+        self.assertEqual("fake string", str1.lstrip())
+        self.assertEqual("fake string  ", str23.lstrip())
+        self.assertEqual("ke string", str1.lstrip("abcdef"))
 
-        self.assertEquals(("fa", "ke", " string"), str1.partition("ke"))
-        self.assertEquals(("fake string", "", ""), str1.partition("asdf"))
+        self.assertEqual(("fa", "ke", " string"), str1.partition("ke"))
+        self.assertEqual(("fake string", "", ""), str1.partition("asdf"))
 
         str24 = _FakeString("boo foo moo")
-        self.assertEquals("real string", str1.replace("fake", "real"))
-        self.assertEquals("bu fu moo", str24.replace("oo", "u", 2))
+        self.assertEqual("real string", str1.replace("fake", "real"))
+        self.assertEqual("bu fu moo", str24.replace("oo", "u", 2))
 
-        self.assertEquals(3, str1.rfind("e"))
-        self.assertEquals(-1, str1.rfind("z"))
-        self.assertEquals(7, str1.rfind("r", 7))
-        self.assertEquals(-1, str1.rfind("r", 8))
-        self.assertEquals(7, str1.rfind("r", 5, 9))
-        self.assertEquals(-1, str1.rfind("r", 5, 7))
+        self.assertEqual(3, str1.rfind("e"))
+        self.assertEqual(-1, str1.rfind("z"))
+        self.assertEqual(7, str1.rfind("r", 7))
+        self.assertEqual(-1, str1.rfind("r", 8))
+        self.assertEqual(7, str1.rfind("r", 5, 9))
+        self.assertEqual(-1, str1.rfind("r", 5, 7))
 
-        self.assertEquals(3, str1.rindex("e"))
+        self.assertEqual(3, str1.rindex("e"))
         self.assertRaises(ValueError, str1.rindex, "z")
-        self.assertEquals(7, str1.rindex("r", 7))
+        self.assertEqual(7, str1.rindex("r", 7))
         self.assertRaises(ValueError, str1.rindex, "r", 8)
-        self.assertEquals(7, str1.rindex("r", 5, 9))
+        self.assertEqual(7, str1.rindex("r", 5, 9))
         self.assertRaises(ValueError, str1.rindex, "r", 5, 7)
 
-        self.assertEquals("    fake string", str1.rjust(15))
-        self.assertEquals("     fake string", str1.rjust(16))
-        self.assertEquals("qqqqfake string", str1.rjust(15, "q"))
+        self.assertEqual("    fake string", str1.rjust(15))
+        self.assertEqual("     fake string", str1.rjust(16))
+        self.assertEqual("qqqqfake string", str1.rjust(15, "q"))
 
-        self.assertEquals(("fa", "ke", " string"), str1.rpartition("ke"))
-        self.assertEquals(("", "", "fake string"), str1.rpartition("asdf"))
+        self.assertEqual(("fa", "ke", " string"), str1.rpartition("ke"))
+        self.assertEqual(("", "", "fake string"), str1.rpartition("asdf"))
 
         str25 = _FakeString("   this is a   sentence with  whitespace ")
         actual = ["this", "is", "a", "sentence", "with", "whitespace"]
-        self.assertEquals(actual, str25.rsplit())
-        self.assertEquals(actual, str25.rsplit(None))
+        self.assertEqual(actual, str25.rsplit())
+        self.assertEqual(actual, str25.rsplit(None))
         actual = ["", "", "", "this", "is", "a", "", "", "sentence", "with",
                   "", "whitespace", ""]
-        self.assertEquals(actual, str25.rsplit(" "))
+        self.assertEqual(actual, str25.rsplit(" "))
         actual = ["   this is a", "sentence", "with", "whitespace"]
-        self.assertEquals(actual, str25.rsplit(None, 3))
+        self.assertEqual(actual, str25.rsplit(None, 3))
         actual = ["   this is a   sentence with", "", "whitespace", ""]
-        self.assertEquals(actual, str25.rsplit(" ", 3))
+        self.assertEqual(actual, str25.rsplit(" ", 3))
         if py3k:
-            self.assertEquals(actual, str25.rsplit(maxsplit=3))
+            self.assertEqual(actual, str25.rsplit(maxsplit=3))
 
-        self.assertEquals("fake string", str1.rstrip())
-        self.assertEquals("  fake string", str23.rstrip())
-        self.assertEquals("fake stri", str1.rstrip("ngr"))
+        self.assertEqual("fake string", str1.rstrip())
+        self.assertEqual("  fake string", str23.rstrip())
+        self.assertEqual("fake stri", str1.rstrip("ngr"))
 
         actual = ["this", "is", "a", "sentence", "with", "whitespace"]
-        self.assertEquals(actual, str25.split())
-        self.assertEquals(actual, str25.split(None))
+        self.assertEqual(actual, str25.split())
+        self.assertEqual(actual, str25.split(None))
         actual = ["", "", "", "this", "is", "a", "", "", "sentence", "with",
                   "", "whitespace", ""]
-        self.assertEquals(actual, str25.split(" "))
+        self.assertEqual(actual, str25.split(" "))
         actual = ["this", "is", "a", "sentence with  whitespace "]
-        self.assertEquals(actual, str25.split(None, 3))
+        self.assertEqual(actual, str25.split(None, 3))
         actual = ["", "", "", "this is a   sentence with  whitespace "]
-        self.assertEquals(actual, str25.split(" ", 3))
+        self.assertEqual(actual, str25.split(" ", 3))
         if py3k:
-            self.assertEquals(actual, str25.split(maxsplit=3))
+            self.assertEqual(actual, str25.split(maxsplit=3))
 
         str26 = _FakeString("lines\nof\ntext\r\nare\r\npresented\nhere")
-        self.assertEquals(["lines", "of", "text", "are", "presented", "here"],
+        self.assertEqual(["lines", "of", "text", "are", "presented", "here"],
                           str26.splitlines())
-        self.assertEquals(["lines\n", "of\n", "text\r\n", "are\r\n",
+        self.assertEqual(["lines\n", "of\n", "text\r\n", "are\r\n",
                            "presented\n", "here"], str26.splitlines(True))
 
         self.assertTrue(str1.startswith("fake"))
         self.assertFalse(str1.startswith("faker"))
 
-        self.assertEquals("fake string", str1.strip())
-        self.assertEquals("fake string", str23.strip())
-        self.assertEquals("ke stri", str1.strip("abcdefngr"))
+        self.assertEqual("fake string", str1.strip())
+        self.assertEqual("fake string", str23.strip())
+        self.assertEqual("ke stri", str1.strip("abcdefngr"))
 
-        self.assertEquals("fOObAR", str16.swapcase())
+        self.assertEqual("fOObAR", str16.swapcase())
 
-        self.assertEquals("Fake String", str1.title())
+        self.assertEqual("Fake String", str1.title())
 
         if py3k:
             table1 = str.maketrans({97: "1", 101: "2", 105: "3", 111: "4",
                                     117: "5"})
             table2 = str.maketrans("aeiou", "12345")
             table3 = str.maketrans("aeiou", "12345", "rts")
-            self.assertEquals("f1k2 str3ng", str1.translate(table1))
-            self.assertEquals("f1k2 str3ng", str1.translate(table2))
-            self.assertEquals("f1k2 3ng", str1.translate(table3))
+            self.assertEqual("f1k2 str3ng", str1.translate(table1))
+            self.assertEqual("f1k2 str3ng", str1.translate(table2))
+            self.assertEqual("f1k2 3ng", str1.translate(table3))
         else:
             table = {97: "1", 101: "2", 105: "3", 111: "4", 117: "5"}
-            self.assertEquals("f1k2 str3ng", str1.translate(table))
+            self.assertEqual("f1k2 str3ng", str1.translate(table))
 
-        self.assertEquals("", str15.upper())
-        self.assertEquals("FOOBAR", str16.upper())
+        self.assertEqual("", str15.upper())
+        self.assertEqual("FOOBAR", str16.upper())
 
-        self.assertEquals("123", str12.zfill(3))
-        self.assertEquals("000123", str12.zfill(6))
+        self.assertEqual("123", str12.zfill(3))
+        self.assertEqual("000123", str12.zfill(6))
 
 if __name__ == "__main__":
     unittest.main(verbosity=2)

tests/test_tokens.py

@@ -42,8 +42,8 @@ class TestTokens(unittest.TestCase):
         token1 = tokens.Token()
         token2 = tokens.Token(foo="bar", baz=123)
 
-        self.assertEquals("bar", token2.foo)
-        self.assertEquals(123, token2.baz)
+        self.assertEqual("bar", token2.foo)
+        self.assertEqual(123, token2.baz)
         self.assertRaises(KeyError, lambda: token1.foo)
         self.assertRaises(KeyError, lambda: token2.bar)
 
@@ -51,8 +51,8 @@ class TestTokens(unittest.TestCase):
         token2.foo = "ham"
         del token2.baz
 
-        self.assertEquals("eggs", token1.spam)
-        self.assertEquals("ham", token2.foo)
+        self.assertEqual("eggs", token1.spam)
+        self.assertEqual("ham", token2.foo)
         self.assertRaises(KeyError, lambda: token2.baz)
         self.assertRaises(KeyError, delattr, token2, "baz")
 
@@ -63,15 +63,15 @@ class TestTokens(unittest.TestCase):
         token3 = tokens.Text(text="earwig" * 100)
         hundredchars = ("earwig" * 100)[:97] + "..."
 
-        self.assertEquals("Token()", repr(token1))
+        self.assertEqual("Token()", repr(token1))
         if py3k:
             token2repr = "Token(foo='bar', baz=123)"
             token3repr = "Text(text='" + hundredchars + "')"
         else:
             token2repr = "Token(foo=u'bar', baz=123)"
             token3repr = "Text(text=u'" + hundredchars + "')"
-        self.assertEquals(token2repr, repr(token2))
-        self.assertEquals(token3repr, repr(token3))
+        self.assertEqual(token2repr, repr(token2))
+        self.assertEqual(token3repr, repr(token3))
 
     def test_equality(self):
         """check that equivalent tokens are considered equal"""
@@ -82,10 +82,10 @@ class TestTokens(unittest.TestCase):
         token5 = tokens.Text(text="asdf")
         token6 = tokens.TemplateOpen(text="asdf")
 
-        self.assertEquals(token1, token2)
-        self.assertEquals(token2, token1)
-        self.assertEquals(token4, token5)
-        self.assertEquals(token5, token4)
+        self.assertEqual(token1, token2)
+        self.assertEqual(token2, token1)
+        self.assertEqual(token4, token5)
+        self.assertEqual(token5, token4)
         self.assertNotEquals(token1, token3)
         self.assertNotEquals(token2, token3)
         self.assertNotEquals(token4, token6)
@@ -99,7 +99,7 @@ class TestTokens(unittest.TestCase):
             tokens.Text(text="earwig")
         ]
         for token in tests:
-            self.assertEquals(token, eval(repr(token), vars(tokens)))
+            self.assertEqual(token, eval(repr(token), vars(tokens)))
 
 if __name__ == "__main__":
     unittest.main(verbosity=2)