From: Sebastian Ramacher <sramacher@debian.org>
Date: Mon, 16 Apr 2018 01:02:09 +0200
Subject: Replace deprecated unittest methods

2to3 in Python 3.3 and Python 3.4 convert files differently if they encounter
any of the deprecated unittests methods. To circumvent this problem, rename
them before running 2to3
Forwarded: not-needed
Last-Update: 2014-02-25
---
 lib/Crypto/SelfTest/Cipher/test_pkcs1_oaep.py   |   2 +-
 lib/Crypto/SelfTest/Hash/common.py              |   8 +-
 lib/Crypto/SelfTest/PublicKey/test_ElGamal.py   |  40 ++++-----
 lib/Crypto/SelfTest/PublicKey/test_RSA.py       |   6 +-
 lib/Crypto/SelfTest/PublicKey/test_importKey.py |  10 +--
 lib/Crypto/SelfTest/Signature/test_pkcs1_15.py  |   8 +-
 lib/Crypto/SelfTest/Signature/test_pkcs1_pss.py |  14 +--
 lib/Crypto/SelfTest/Util/test_asn1.py           | 112 ++++++++++++------------
 8 files changed, 100 insertions(+), 100 deletions(-)

diff --git a/lib/Crypto/SelfTest/Cipher/test_pkcs1_oaep.py b/lib/Crypto/SelfTest/Cipher/test_pkcs1_oaep.py
index 7ca5c15..d30fc5f 100644
--- a/lib/Crypto/SelfTest/Cipher/test_pkcs1_oaep.py
+++ b/lib/Crypto/SelfTest/Cipher/test_pkcs1_oaep.py
@@ -336,7 +336,7 @@ class PKCS1_OAEP_Tests(unittest.TestCase):
                     cipher = PKCS.new(self.key1024, hashmod)
                     ct = cipher.encrypt(pt)
                     self.assertEqual(cipher.decrypt(ct), pt)
-                    self.failUnless(asked > hashmod.digest_size)
+                    self.assertTrue(asked > hashmod.digest_size)
 
         def testEncryptDecrypt3(self):
                 # Verify that OAEP supports labels
diff --git a/lib/Crypto/SelfTest/Hash/common.py b/lib/Crypto/SelfTest/Hash/common.py
index f77fb0f..fe36a78 100644
--- a/lib/Crypto/SelfTest/Hash/common.py
+++ b/lib/Crypto/SelfTest/Hash/common.py
@@ -53,11 +53,11 @@ class HashDigestSizeSelfTest(unittest.TestCase):
         return self.description
 
     def runTest(self):
-        self.failUnless(hasattr(self.hashmod, "digest_size"))
-        self.assertEquals(self.hashmod.digest_size, self.expected)
+        self.assertTrue(hasattr(self.hashmod, "digest_size"))
+        self.assertEqual(self.hashmod.digest_size, self.expected)
         h = self.hashmod.new()
-        self.failUnless(hasattr(h, "digest_size"))
-        self.assertEquals(h.digest_size, self.expected)
+        self.assertTrue(hasattr(h, "digest_size"))
+        self.assertEqual(h.digest_size, self.expected)
 
 
 class HashSelfTest(unittest.TestCase):
diff --git a/lib/Crypto/SelfTest/PublicKey/test_ElGamal.py b/lib/Crypto/SelfTest/PublicKey/test_ElGamal.py
index cdee8cf..7b03115 100644
--- a/lib/Crypto/SelfTest/PublicKey/test_ElGamal.py
+++ b/lib/Crypto/SelfTest/PublicKey/test_ElGamal.py
@@ -105,8 +105,8 @@ class ElGamalTest(unittest.TestCase):
                 d = self.convert_tv(tv, as_longs)
                 key = ElGamal.construct(d['key'])
                 ct = key.encrypt(d['pt'], d['k'])
-                self.assertEquals(ct[0], d['ct1'])
-                self.assertEquals(ct[1], d['ct2'])
+                self.assertEqual(ct[0], d['ct1'])
+                self.assertEqual(ct[1], d['ct2'])
 
     def test_decryption(self):
         for tv in self.tve:
@@ -114,7 +114,7 @@ class ElGamalTest(unittest.TestCase):
                 d = self.convert_tv(tv, as_longs)
                 key = ElGamal.construct(d['key'])
                 pt = key.decrypt((d['ct1'], d['ct2']))
-                self.assertEquals(pt, d['pt'])
+                self.assertEqual(pt, d['pt'])
 
     def test_signing(self):
         for tv in self.tvs:
@@ -122,8 +122,8 @@ class ElGamalTest(unittest.TestCase):
                 d = self.convert_tv(tv, as_longs)
                 key = ElGamal.construct(d['key'])
                 sig1, sig2 = key.sign(d['h'], d['k'])
-                self.assertEquals(sig1, d['sig1'])
-                self.assertEquals(sig2, d['sig2'])
+                self.assertEqual(sig1, d['sig1'])
+                self.assertEqual(sig2, d['sig2'])
 
     def test_verification(self):
         for tv in self.tvs:
@@ -132,10 +132,10 @@ class ElGamalTest(unittest.TestCase):
                 key = ElGamal.construct(d['key'])
                 # Positive test
                 res = key.verify( d['h'], (d['sig1'],d['sig2']) )
-                self.failUnless(res)
+                self.assertTrue(res)
                 # Negative test
                 res = key.verify( d['h'], (d['sig1']+1,d['sig2']) )
-                self.failIf(res)
+                self.assertFalse(res)
 
     def convert_tv(self, tv, as_longs=0):
         """Convert a test vector from textual form (hexadecimal ascii
@@ -163,33 +163,33 @@ class ElGamalTest(unittest.TestCase):
     def _check_private_key(self, elgObj):
 
         # Check capabilities
-        self.failUnless(elgObj.has_private())
-        self.failUnless(elgObj.can_sign())
-        self.failUnless(elgObj.can_encrypt())
+        self.assertTrue(elgObj.has_private())
+        self.assertTrue(elgObj.can_sign())
+        self.assertTrue(elgObj.can_encrypt())
 
         # Sanity check key data
-        self.failUnless(1<elgObj.g<(elgObj.p-1))
-        self.assertEquals(pow(elgObj.g, elgObj.p-1, elgObj.p), 1)
-        self.failUnless(1<elgObj.x<(elgObj.p-1))
-        self.assertEquals(pow(elgObj.g, elgObj.x, elgObj.p), elgObj.y)
+        self.assertTrue(1<elgObj.g<(elgObj.p-1))
+        self.assertEqual(pow(elgObj.g, elgObj.p-1, elgObj.p), 1)
+        self.assertTrue(1<elgObj.x<(elgObj.p-1))
+        self.assertEqual(pow(elgObj.g, elgObj.x, elgObj.p), elgObj.y)
 
     def _check_public_key(self, elgObj):
 
         # Check capabilities
-        self.failIf(elgObj.has_private())
-        self.failUnless(elgObj.can_sign())
-        self.failUnless(elgObj.can_encrypt())
+        self.assertFalse(elgObj.has_private())
+        self.assertTrue(elgObj.can_sign())
+        self.assertTrue(elgObj.can_encrypt())
 
         # Sanity check key data
-        self.failUnless(1<elgObj.g<(elgObj.p-1))
-        self.assertEquals(pow(elgObj.g, elgObj.p-1, elgObj.p), 1)
+        self.assertTrue(1<elgObj.g<(elgObj.p-1))
+        self.assertEqual(pow(elgObj.g, elgObj.p-1, elgObj.p), 1)
 
     def _exercise_primitive(self, elgObj):
         # Test encryption/decryption
         plaintext = b("Test")
         ciphertext = elgObj.encrypt(plaintext, 123456789L)
         plaintextP = elgObj.decrypt(ciphertext)
-        self.assertEquals(plaintext, plaintextP)
+        self.assertEqual(plaintext, plaintextP)
 
         # Test signature/verification
         signature = elgObj.sign(plaintext, 987654321L)
diff --git a/lib/Crypto/SelfTest/PublicKey/test_RSA.py b/lib/Crypto/SelfTest/PublicKey/test_RSA.py
index c971042..811c01c 100644
--- a/lib/Crypto/SelfTest/PublicKey/test_RSA.py
+++ b/lib/Crypto/SelfTest/PublicKey/test_RSA.py
@@ -172,9 +172,9 @@ class RSATest(unittest.TestCase):
 
     def test_factoring(self):
         rsaObj = self.rsa.construct([self.n, self.e, self.d])
-        self.failUnless(rsaObj.p==self.p or rsaObj.p==self.q)
-        self.failUnless(rsaObj.q==self.p or rsaObj.q==self.q)
-        self.failUnless(rsaObj.q*rsaObj.p == self.n)
+        self.assertTrue(rsaObj.p==self.p or rsaObj.p==self.q)
+        self.assertTrue(rsaObj.q==self.p or rsaObj.q==self.q)
+        self.assertTrue(rsaObj.q*rsaObj.p == self.n)
 
         self.assertRaises(ValueError, self.rsa.construct, [self.n, self.e, self.n-1])
 
diff --git a/lib/Crypto/SelfTest/PublicKey/test_importKey.py b/lib/Crypto/SelfTest/PublicKey/test_importKey.py
index 0e41577..d59be13 100644
--- a/lib/Crypto/SelfTest/PublicKey/test_importKey.py
+++ b/lib/Crypto/SelfTest/PublicKey/test_importKey.py
@@ -158,7 +158,7 @@ Lr7UkvEtFrRhDDKMtuIIq19FrL4pUIMymPMSLBn3hJLe30Dw48GQM4UCAwEAAQ==
     def testImportKey1(self):
         """Verify import of RSAPrivateKey DER SEQUENCE"""
         key = self.rsa.importKey(self.rsaKeyDER)
-        self.failUnless(key.has_private())
+        self.assertTrue(key.has_private())
         self.assertEqual(key.n, self.n)
         self.assertEqual(key.e, self.e)
         self.assertEqual(key.d, self.d)
@@ -168,7 +168,7 @@ Lr7UkvEtFrRhDDKMtuIIq19FrL4pUIMymPMSLBn3hJLe30Dw48GQM4UCAwEAAQ==
     def testImportKey2(self):
         """Verify import of SubjectPublicKeyInfo DER SEQUENCE"""
         key = self.rsa.importKey(self.rsaPublicKeyDER)
-        self.failIf(key.has_private())
+        self.assertFalse(key.has_private())
         self.assertEqual(key.n, self.n)
         self.assertEqual(key.e, self.e)
 
@@ -228,7 +228,7 @@ Lr7UkvEtFrRhDDKMtuIIq19FrL4pUIMymPMSLBn3hJLe30Dw48GQM4UCAwEAAQ==
         """Verify import of encrypted PrivateKeyInfo DER SEQUENCE"""
         for t in self.rsaKeyEncryptedPEM:
             key = self.rsa.importKey(t[1], t[0])
-            self.failUnless(key.has_private())
+            self.assertTrue(key.has_private())
             self.assertEqual(key.n, self.n)
             self.assertEqual(key.e, self.e)
             self.assertEqual(key.d, self.d)
@@ -238,7 +238,7 @@ Lr7UkvEtFrRhDDKMtuIIq19FrL4pUIMymPMSLBn3hJLe30Dw48GQM4UCAwEAAQ==
     def testImportKey9(self):
         """Verify import of unencrypted PrivateKeyInfo DER SEQUENCE"""
         key = self.rsa.importKey(self.rsaKeyDER8)
-        self.failUnless(key.has_private())
+        self.assertTrue(key.has_private())
         self.assertEqual(key.n, self.n)
         self.assertEqual(key.e, self.e)
         self.assertEqual(key.d, self.d)
@@ -248,7 +248,7 @@ Lr7UkvEtFrRhDDKMtuIIq19FrL4pUIMymPMSLBn3hJLe30Dw48GQM4UCAwEAAQ==
     def testImportKey10(self):
         """Verify import of unencrypted PrivateKeyInfo DER SEQUENCE, encoded with PEM"""
         key = self.rsa.importKey(self.rsaKeyPEM8)
-        self.failUnless(key.has_private())
+        self.assertTrue(key.has_private())
         self.assertEqual(key.n, self.n)
         self.assertEqual(key.e, self.e)
         self.assertEqual(key.d, self.d)
diff --git a/lib/Crypto/SelfTest/Signature/test_pkcs1_15.py b/lib/Crypto/SelfTest/Signature/test_pkcs1_15.py
index bc36696..ee9c106 100644
--- a/lib/Crypto/SelfTest/Signature/test_pkcs1_15.py
+++ b/lib/Crypto/SelfTest/Signature/test_pkcs1_15.py
@@ -168,7 +168,7 @@ class PKCS1_15_Tests(unittest.TestCase):
                             h.update(b(row[1]))
                         # The real test
                         signer = PKCS.new(key)
-                        self.failUnless(signer.can_sign())
+                        self.assertTrue(signer.can_sign())
                         s = signer.sign(h)
                         self.assertEqual(s, t2b(row[2]))
 
@@ -189,9 +189,9 @@ class PKCS1_15_Tests(unittest.TestCase):
                             h.update(b(row[1]))
                         # The real test
                         verifier = PKCS.new(key)
-                        self.failIf(verifier.can_sign())
+                        self.assertFalse(verifier.can_sign())
                         result = verifier.verify(h, t2b(row[2]))
-                        self.failUnless(result)
+                        self.assertTrue(result)
 
         def testSignVerify(self):
                         rng = Random.new().read
@@ -204,7 +204,7 @@ class PKCS1_15_Tests(unittest.TestCase):
                             signer = PKCS.new(key)
                             s = signer.sign(h)
                             result = signer.verify(h, s)
-                            self.failUnless(result)
+                            self.assertTrue(result)
 
 
 def get_tests(config={}):
diff --git a/lib/Crypto/SelfTest/Signature/test_pkcs1_pss.py b/lib/Crypto/SelfTest/Signature/test_pkcs1_pss.py
index f5256a5..b8067e4 100644
--- a/lib/Crypto/SelfTest/Signature/test_pkcs1_pss.py
+++ b/lib/Crypto/SelfTest/Signature/test_pkcs1_pss.py
@@ -357,7 +357,7 @@ class PKCS1_PSS_Tests(unittest.TestCase):
                         key._randfunc = lambda N: test_salt
                         # The real test
                         signer = PKCS.new(key)
-                        self.failUnless(signer.can_sign())
+                        self.assertTrue(signer.can_sign())
                         s = signer.sign(h)
                         self.assertEqual(s, t2b(self._testData[i][2]))
 
@@ -375,9 +375,9 @@ class PKCS1_PSS_Tests(unittest.TestCase):
                         # The real test
                         key._randfunc = lambda N: test_salt
                         verifier = PKCS.new(key)
-                        self.failIf(verifier.can_sign())
+                        self.assertFalse(verifier.can_sign())
                         result = verifier.verify(h, t2b(self._testData[i][2]))
-                        self.failUnless(result)
+                        self.assertTrue(result)
 
         def testSignVerify(self):
                         h = SHA.new()
@@ -403,7 +403,7 @@ class PKCS1_PSS_Tests(unittest.TestCase):
                             key.asked = 0
                             signer = PKCS.new(key)
                             s = signer.sign(h)
-                            self.failUnless(signer.verify(h, s))
+                            self.assertTrue(signer.verify(h, s))
                             self.assertEqual(key.asked, h.digest_size)
 
                         h = SHA.new()
@@ -415,14 +415,14 @@ class PKCS1_PSS_Tests(unittest.TestCase):
                             signer = PKCS.new(key, saltLen=sLen)
                             s = signer.sign(h)
                             self.assertEqual(key.asked, sLen)
-                            self.failUnless(signer.verify(h, s))
+                            self.assertTrue(signer.verify(h, s))
 
                         # Verify that sign() uses the custom MGF
                         mgfcalls = 0
                         signer = PKCS.new(key, newMGF)
                         s = signer.sign(h)
                         self.assertEqual(mgfcalls, 1)
-                        self.failUnless(signer.verify(h, s))
+                        self.assertTrue(signer.verify(h, s))
 
                         # Verify that sign() does not call the RNG
                         # when salt length is 0, even when a new MGF is provided
@@ -432,7 +432,7 @@ class PKCS1_PSS_Tests(unittest.TestCase):
                         s = signer.sign(h)
                         self.assertEqual(key.asked,0)
                         self.assertEqual(mgfcalls, 1)
-                        self.failUnless(signer.verify(h, s))
+                        self.assertTrue(signer.verify(h, s))
 
 def get_tests(config={}):
     tests = []
diff --git a/lib/Crypto/SelfTest/Util/test_asn1.py b/lib/Crypto/SelfTest/Util/test_asn1.py
index bbd0a39..e3d15aa 100644
--- a/lib/Crypto/SelfTest/Util/test_asn1.py
+++ b/lib/Crypto/SelfTest/Util/test_asn1.py
@@ -35,86 +35,86 @@ class DerObjectTests(unittest.TestCase):
 	def testObjEncode1(self):
 		# No payload
 		der = DerObject(b('\x33'))
-		self.assertEquals(der.encode(), b('\x33\x00'))
+		self.assertEqual(der.encode(), b('\x33\x00'))
 		# Small payload
 		der.payload = b('\x45')
-		self.assertEquals(der.encode(), b('\x33\x01\x45'))
+		self.assertEqual(der.encode(), b('\x33\x01\x45'))
 		# Invariant
-		self.assertEquals(der.encode(), b('\x33\x01\x45'))
+		self.assertEqual(der.encode(), b('\x33\x01\x45'))
 		# Initialize with numerical tag
 		der = DerObject(b(0x33))
 		der.payload = b('\x45')
-		self.assertEquals(der.encode(), b('\x33\x01\x45'))
+		self.assertEqual(der.encode(), b('\x33\x01\x45'))
 
 	def testObjEncode2(self):
 		# Known types
 		der = DerObject('SEQUENCE')
-		self.assertEquals(der.encode(), b('\x30\x00'))
+		self.assertEqual(der.encode(), b('\x30\x00'))
 		der = DerObject('BIT STRING')
-		self.assertEquals(der.encode(), b('\x03\x00'))
+		self.assertEqual(der.encode(), b('\x03\x00'))
 		
 	def testObjEncode3(self):
 		# Long payload
 		der = DerObject(b('\x34'))
 		der.payload = b("0")*128
-		self.assertEquals(der.encode(), b('\x34\x81\x80' + "0"*128))		
+		self.assertEqual(der.encode(), b('\x34\x81\x80' + "0"*128))		
 
 	def testObjDecode1(self):
 		# Decode short payload
 		der = DerObject()
 		der.decode(b('\x20\x02\x01\x02'))
-		self.assertEquals(der.payload, b("\x01\x02"))
-		self.assertEquals(der.typeTag, 0x20)
+		self.assertEqual(der.payload, b("\x01\x02"))
+		self.assertEqual(der.typeTag, 0x20)
 
 	def testObjDecode2(self):
 		# Decode short payload
 		der = DerObject()
 		der.decode(b('\x22\x81\x80' + "1"*128))
-		self.assertEquals(der.payload, b("1")*128)
-		self.assertEquals(der.typeTag, 0x22)
+		self.assertEqual(der.payload, b("1")*128)
+		self.assertEqual(der.typeTag, 0x22)
 
 class DerSequenceTests(unittest.TestCase):
 
 	def testEncode1(self):
 		# Empty sequence
 		der = DerSequence()
-		self.assertEquals(der.encode(), b('0\x00'))
-		self.failIf(der.hasOnlyInts())
+		self.assertEqual(der.encode(), b('0\x00'))
+		self.assertFalse(der.hasOnlyInts())
 		# One single-byte integer (zero)
 		der.append(0)
-		self.assertEquals(der.encode(), b('0\x03\x02\x01\x00'))
-		self.failUnless(der.hasOnlyInts())
+		self.assertEqual(der.encode(), b('0\x03\x02\x01\x00'))
+		self.assertTrue(der.hasOnlyInts())
 		# Invariant
-		self.assertEquals(der.encode(), b('0\x03\x02\x01\x00'))
+		self.assertEqual(der.encode(), b('0\x03\x02\x01\x00'))
 
 	def testEncode2(self):
 		# One single-byte integer (non-zero)
 		der = DerSequence()
 		der.append(127)
-		self.assertEquals(der.encode(), b('0\x03\x02\x01\x7f'))
+		self.assertEqual(der.encode(), b('0\x03\x02\x01\x7f'))
 		# Indexing
 		der[0] = 1
-		self.assertEquals(len(der),1)
-		self.assertEquals(der[0],1)
-		self.assertEquals(der[-1],1)
-		self.assertEquals(der.encode(), b('0\x03\x02\x01\x01'))
+		self.assertEqual(len(der),1)
+		self.assertEqual(der[0],1)
+		self.assertEqual(der[-1],1)
+		self.assertEqual(der.encode(), b('0\x03\x02\x01\x01'))
 		#
 		der[:] = [1]
-		self.assertEquals(len(der),1)
-		self.assertEquals(der[0],1)
-		self.assertEquals(der.encode(), b('0\x03\x02\x01\x01'))
+		self.assertEqual(len(der),1)
+		self.assertEqual(der[0],1)
+		self.assertEqual(der.encode(), b('0\x03\x02\x01\x01'))
 	
 	def testEncode3(self):
 		# One multi-byte integer (non-zero)
 		der = DerSequence()
 		der.append(0x180L)
-		self.assertEquals(der.encode(), b('0\x04\x02\x02\x01\x80'))
+		self.assertEqual(der.encode(), b('0\x04\x02\x02\x01\x80'))
 	
 	def testEncode4(self):
 		# One very long integer
 		der = DerSequence()
 		der.append(2**2048)
-		self.assertEquals(der.encode(), b('0\x82\x01\x05')+
+		self.assertEqual(der.encode(), b('0\x82\x01\x05')+
 		b('\x02\x82\x01\x01\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00')+
 		b('\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00')+
 		b('\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00')+
@@ -139,30 +139,30 @@ class DerSequenceTests(unittest.TestCase):
 		# One single-byte integer (looks negative)
 		der = DerSequence()
 		der.append(0xFFL)
-		self.assertEquals(der.encode(), b('0\x04\x02\x02\x00\xff'))
+		self.assertEqual(der.encode(), b('0\x04\x02\x02\x00\xff'))
 	
 	def testEncode6(self):
 		# Two integers
 		der = DerSequence()
 		der.append(0x180L)
 		der.append(0xFFL)
-		self.assertEquals(der.encode(), b('0\x08\x02\x02\x01\x80\x02\x02\x00\xff'))
-		self.failUnless(der.hasOnlyInts())
+		self.assertEqual(der.encode(), b('0\x08\x02\x02\x01\x80\x02\x02\x00\xff'))
+		self.assertTrue(der.hasOnlyInts())
 		#
 		der.append(0x01)
 		der[1:] = [9,8]
-		self.assertEquals(len(der),3)
+		self.assertEqual(len(der),3)
 		self.assertEqual(der[1:],[9,8])
 		self.assertEqual(der[1:-1],[9])
-		self.assertEquals(der.encode(), b('0\x0A\x02\x02\x01\x80\x02\x01\x09\x02\x01\x08'))
+		self.assertEqual(der.encode(), b('0\x0A\x02\x02\x01\x80\x02\x01\x09\x02\x01\x08'))
 
 	def testEncode7(self):
 		# One integer and another type (no matter what it is)
 		der = DerSequence()
 		der.append(0x180L)
 		der.append(b('\x00\x02\x00\x00'))
-		self.assertEquals(der.encode(), b('0\x08\x02\x02\x01\x80\x00\x02\x00\x00'))
-		self.failIf(der.hasOnlyInts())
+		self.assertEqual(der.encode(), b('0\x08\x02\x02\x01\x80\x00\x02\x00\x00'))
+		self.assertFalse(der.hasOnlyInts())
 
 	####
 
@@ -170,29 +170,29 @@ class DerSequenceTests(unittest.TestCase):
 		# Empty sequence
 		der = DerSequence()
 		der.decode(b('0\x00'))
-		self.assertEquals(len(der),0)
+		self.assertEqual(len(der),0)
 		# One single-byte integer (zero)
 		der.decode(b('0\x03\x02\x01\x00'))
-		self.assertEquals(len(der),1)
-		self.assertEquals(der[0],0)
+		self.assertEqual(len(der),1)
+		self.assertEqual(der[0],0)
 		# Invariant
 		der.decode(b('0\x03\x02\x01\x00'))
-		self.assertEquals(len(der),1)
-		self.assertEquals(der[0],0)
+		self.assertEqual(len(der),1)
+		self.assertEqual(der[0],0)
 
 	def testDecode2(self):
 		# One single-byte integer (non-zero)
 		der = DerSequence()
 		der.decode(b('0\x03\x02\x01\x7f'))
-		self.assertEquals(len(der),1)
-		self.assertEquals(der[0],127)
+		self.assertEqual(len(der),1)
+		self.assertEqual(der[0],127)
 	
 	def testDecode3(self):
 		# One multi-byte integer (non-zero)
 		der = DerSequence()
 		der.decode(b('0\x04\x02\x02\x01\x80'))
-		self.assertEquals(len(der),1)
-		self.assertEquals(der[0],0x180L)
+		self.assertEqual(len(der),1)
+		self.assertEqual(der[0],0x180L)
 
 	def testDecode4(self):
 		# One very long integer
@@ -217,40 +217,40 @@ class DerSequenceTests(unittest.TestCase):
 		b('\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00')+
 		b('\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00')+
 		b('\x00\x00\x00\x00\x00\x00\x00\x00\x00'))
-		self.assertEquals(len(der),1)
-		self.assertEquals(der[0],2**2048)
+		self.assertEqual(len(der),1)
+		self.assertEqual(der[0],2**2048)
 
 	def testDecode5(self):
 		# One single-byte integer (looks negative)
 		der = DerSequence()
 		der.decode(b('0\x04\x02\x02\x00\xff'))
-		self.assertEquals(len(der),1)
-		self.assertEquals(der[0],0xFFL)
+		self.assertEqual(len(der),1)
+		self.assertEqual(der[0],0xFFL)
 
 	def testDecode6(self):
 		# Two integers
 		der = DerSequence()
 		der.decode(b('0\x08\x02\x02\x01\x80\x02\x02\x00\xff'))
-		self.assertEquals(len(der),2)
-		self.assertEquals(der[0],0x180L)
-		self.assertEquals(der[1],0xFFL)
+		self.assertEqual(len(der),2)
+		self.assertEqual(der[0],0x180L)
+		self.assertEqual(der[1],0xFFL)
 
 	def testDecode7(self):
 		# One integer and 2 other types
 		der = DerSequence()
 		der.decode(b('0\x0A\x02\x02\x01\x80\x24\x02\xb6\x63\x12\x00'))
-		self.assertEquals(len(der),3)
-		self.assertEquals(der[0],0x180L)
-		self.assertEquals(der[1],b('\x24\x02\xb6\x63'))
-		self.assertEquals(der[2],b('\x12\x00'))
+		self.assertEqual(len(der),3)
+		self.assertEqual(der[0],0x180L)
+		self.assertEqual(der[1],b('\x24\x02\xb6\x63'))
+		self.assertEqual(der[2],b('\x12\x00'))
 
 	def testDecode8(self):
 		# Only 2 other types
 		der = DerSequence()
 		der.decode(b('0\x06\x24\x02\xb6\x63\x12\x00'))
-		self.assertEquals(len(der),2)
-		self.assertEquals(der[0],b('\x24\x02\xb6\x63'))
-		self.assertEquals(der[1],b('\x12\x00'))
+		self.assertEqual(len(der),2)
+		self.assertEqual(der[0],b('\x24\x02\xb6\x63'))
+		self.assertEqual(der[1],b('\x12\x00'))
 
 	def testErrDecode1(self):
 		# Not a sequence