Description: 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
Author: Sebastian Ramacher <sramacher@debian.org>
Forwarded: not-needed
Last-Update: 2014-02-25

--- python-crypto-2.6.1.orig/lib/Crypto/SelfTest/Cipher/test_pkcs1_oaep.py
+++ python-crypto-2.6.1/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
--- python-crypto-2.6.1.orig/lib/Crypto/SelfTest/Hash/common.py
+++ python-crypto-2.6.1/lib/Crypto/SelfTest/Hash/common.py
@@ -53,11 +53,11 @@ class HashDigestSizeSelfTest(unittest.Te
         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):
--- python-crypto-2.6.1.orig/lib/Crypto/SelfTest/PublicKey/test_ElGamal.py
+++ python-crypto-2.6.1/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)
--- python-crypto-2.6.1.orig/lib/Crypto/SelfTest/PublicKey/test_RSA.py
+++ python-crypto-2.6.1/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])
 
--- python-crypto-2.6.1.orig/lib/Crypto/SelfTest/PublicKey/test_importKey.py
+++ python-crypto-2.6.1/lib/Crypto/SelfTest/PublicKey/test_importKey.py
@@ -158,7 +158,7 @@ Lr7UkvEtFrRhDDKMtuIIq19FrL4pUIMymPMSLBn3
     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 @@ Lr7UkvEtFrRhDDKMtuIIq19FrL4pUIMymPMSLBn3
     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 @@ Lr7UkvEtFrRhDDKMtuIIq19FrL4pUIMymPMSLBn3
         """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 @@ Lr7UkvEtFrRhDDKMtuIIq19FrL4pUIMymPMSLBn3
     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 @@ Lr7UkvEtFrRhDDKMtuIIq19FrL4pUIMymPMSLBn3
     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)
--- python-crypto-2.6.1.orig/lib/Crypto/SelfTest/Signature/test_pkcs1_15.py
+++ python-crypto-2.6.1/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={}):
--- python-crypto-2.6.1.orig/lib/Crypto/SelfTest/Signature/test_pkcs1_pss.py
+++ python-crypto-2.6.1/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 = []
--- python-crypto-2.6.1.orig/lib/Crypto/SelfTest/Util/test_asn1.py
+++ python-crypto-2.6.1/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