Use assertEqual instead of assertEquals

Author: slozier

Tests/test_array.py

@@ -159,17 +159,17 @@ def test_creation(self):
     def test_constructor(self):
         array1 = System.Array[int](10)
         array2 = System.Array.CreateInstance(System.Int32, 10)
-        self.assertEquals(len(array1), len(array2))
+        self.assertEqual(len(array1), len(array2))
         for i in range(len(array1)):
-            self.assertEquals(array1[i], 0)
-            self.assertEquals(array1[i], array2[i])
+            self.assertEqual(array1[i], 0)
+            self.assertEqual(array1[i], array2[i])
 
         # 2-dimensional
         array3 = System.Array[System.Byte](3, 4)
-        self.assertEquals(array3.Rank, 2)
+        self.assertEqual(array3.Rank, 2)
         for x in range(array3.GetLength(0)):
             for y in range(array3.GetLength(1)):
-                self.assertEquals(array3[x, y], 0)
+                self.assertEqual(array3[x, y], 0)
 
     def test_nonzero_lowerbound(self):
         a = System.Array.CreateInstance(int, (5,), (5,))

Tests/test_bytes.py

@@ -607,60 +607,60 @@ def test_iterator_length_hint(self):
             b = testType(b"abc")
 
             it = iter(b)
-            self.assertEquals(it.__length_hint__(), 3)
-            self.assertEquals(next(it), ord("a"))
-            self.assertEquals(it.__length_hint__(), 2)
-            self.assertEquals(next(it), ord("b"))
-            self.assertEquals(it.__length_hint__(), 1)
-            self.assertEquals(next(it), ord("c"))
-            self.assertEquals(it.__length_hint__(), 0)
+            self.assertEqual(it.__length_hint__(), 3)
+            self.assertEqual(next(it), ord("a"))
+            self.assertEqual(it.__length_hint__(), 2)
+            self.assertEqual(next(it), ord("b"))
+            self.assertEqual(it.__length_hint__(), 1)
+            self.assertEqual(next(it), ord("c"))
+            self.assertEqual(it.__length_hint__(), 0)
 
             self.assertRaises(StopIteration, next, it)
-            self.assertEquals(it.__length_hint__(), 0)
+            self.assertEqual(it.__length_hint__(), 0)
 
     def test_iterator_reduce(self):
         for testType in types:
             b = testType(b"abc")
 
             it = iter(b)
-            self.assertEquals(it.__reduce__(), (iter, (b"abc",), 0))
-            self.assertEquals(next(it), ord("a"))
-            self.assertEquals(it.__reduce__(), (iter, (b"abc",), 1))
-            self.assertEquals(next(it), ord("b"))
-            self.assertEquals(it.__reduce__(), (iter, (b"abc",), 2))
-            self.assertEquals(next(it), ord("c"))
-            self.assertEquals(it.__reduce__(), (iter, (b"abc",), 3))
+            self.assertEqual(it.__reduce__(), (iter, (b"abc",), 0))
+            self.assertEqual(next(it), ord("a"))
+            self.assertEqual(it.__reduce__(), (iter, (b"abc",), 1))
+            self.assertEqual(next(it), ord("b"))
+            self.assertEqual(it.__reduce__(), (iter, (b"abc",), 2))
+            self.assertEqual(next(it), ord("c"))
+            self.assertEqual(it.__reduce__(), (iter, (b"abc",), 3))
 
             self.assertRaises(StopIteration, next, it)
             empty_reduce = it.__reduce__()
-            self.assertEquals(len(empty_reduce), 2)
-            self.assertEquals(empty_reduce[0], iter)
-            self.assertEquals(len(empty_reduce[1]), 1)
-            self.assertEquals(len(empty_reduce[1][0]), 0)
+            self.assertEqual(len(empty_reduce), 2)
+            self.assertEqual(empty_reduce[0], iter)
+            self.assertEqual(len(empty_reduce[1]), 1)
+            self.assertEqual(len(empty_reduce[1][0]), 0)
 
             it = iter(testType(b""))
-            self.assertEquals(it.__reduce__(), (iter, (b"",), 0))
+            self.assertEqual(it.__reduce__(), (iter, (b"",), 0))
 
     def test_iterator_setstate(self):
         for testType in types:
             b = testType(b"abc")
 
             it = iter(b)
-            self.assertEquals(next(it), ord("a"))
-            self.assertEquals(next(it), ord("b"))
-            self.assertEquals(next(it), ord("c"))
+            self.assertEqual(next(it), ord("a"))
+            self.assertEqual(next(it), ord("b"))
+            self.assertEqual(next(it), ord("c"))
             self.assertRaises(StopIteration, next, it)
 
             it = iter(b)
-            self.assertEquals(next(it), ord("a"))
+            self.assertEqual(next(it), ord("a"))
             it.__setstate__(0)
-            self.assertEquals(next(it), ord("a"))
+            self.assertEqual(next(it), ord("a"))
             it.__setstate__(-10)
-            self.assertEquals(next(it), ord("a"))
+            self.assertEqual(next(it), ord("a"))
             it.__setstate__(2)
-            self.assertEquals(next(it), ord("c"))
+            self.assertEqual(next(it), ord("c"))
             it.__setstate__(1)
-            self.assertEquals(next(it), ord("b"))
+            self.assertEqual(next(it), ord("b"))
             it.__setstate__(3)
             self.assertRaises(StopIteration, next, it)
             it.__setstate__(0)

Tests/test_iterator.py

@@ -299,7 +299,7 @@ def test_discarded_indexer_reduces_empty(self):
         list(it)
         with self.assertRaises(StopIteration):
             it.__next__()
-        self.assertEquals(it.__reduce__(), (iter, ((),)))
+        self.assertEqual(it.__reduce__(), (iter, ((),)))
         # Ensure that the iterator is discarded instead of being
         # reset by __setstate__()
         it.__setstate__(0)

Tests/test_str.py

@@ -307,8 +307,8 @@ def __str__(self) -> str:
 
         self.assertIs(type(repr(A())), mystr)
         self.assertIs(type(str(A())), mystr)
-        self.assertEquals(repr(A()), "__repr__ called")
-        self.assertEquals(str(A()), "__str__ called")
+        self.assertEqual(repr(A()), "__repr__ called")
+        self.assertEqual(str(A()), "__str__ called")
 
     @skipUnlessIronPython()
     def test_str_char_hash(self):