[Python-modules-commits] r27932 - in packages/python-crypto/trunk/debian (4 files)
sramacher at users.alioth.debian.org
sramacher at users.alioth.debian.org
Tue Feb 25 21:02:57 UTC 2014
Date: Tuesday, February 25, 2014 @ 21:02:56
Author: sramacher
Revision: 27932
debian/patches/deprecated-test-methods.patch: Replace deprecated unittest
methods. Python 3.3's and 3.4's 2to3 generate different files otherwise.
Added:
packages/python-crypto/trunk/debian/patches/deprecated-test-methods.patch
Modified:
packages/python-crypto/trunk/debian/changelog
packages/python-crypto/trunk/debian/patches/series
packages/python-crypto/trunk/debian/rules
Modified: packages/python-crypto/trunk/debian/changelog
===================================================================
--- packages/python-crypto/trunk/debian/changelog 2014-02-25 20:12:14 UTC (rev 27931)
+++ packages/python-crypto/trunk/debian/changelog 2014-02-25 21:02:56 UTC (rev 27932)
@@ -12,10 +12,9 @@
- debian/control: Move python-docutils and python-epydoc to
Build-Depends-Indep.
- debian/rules: Build documentation in override_dh_auto_build-indep.
+ * debian/patches/deprecated-test-methods.patch: Replace deprecated unittest
+ methods. Python 3.3's and 3.4's 2to3 generate different files otherwise.
- TODO: python-module-in-wrong-location (due to whitespace differences files
- end up in /usr/lib/python3.4)
-
-- Sebastian Ramacher <sramacher at debian.org> Tue, 25 Feb 2014 18:36:18 +0100
python-crypto (2.6.1-3) unstable; urgency=low
Added: packages/python-crypto/trunk/debian/patches/deprecated-test-methods.patch
===================================================================
--- packages/python-crypto/trunk/debian/patches/deprecated-test-methods.patch (rev 0)
+++ packages/python-crypto/trunk/debian/patches/deprecated-test-methods.patch 2014-02-25 21:02:56 UTC (rev 27932)
@@ -0,0 +1,529 @@
+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 at 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
Modified: packages/python-crypto/trunk/debian/patches/series
===================================================================
--- packages/python-crypto/trunk/debian/patches/series 2014-02-25 20:12:14 UTC (rev 27931)
+++ packages/python-crypto/trunk/debian/patches/series 2014-02-25 21:02:56 UTC (rev 27932)
@@ -7,3 +7,4 @@
fix-except-shadows-builtin.patch
multiprocessing-test.patch
unittest-stream.patch
+deprecated-test-methods.patch
Modified: packages/python-crypto/trunk/debian/rules
===================================================================
--- packages/python-crypto/trunk/debian/rules 2014-02-25 20:12:14 UTC (rev 27931)
+++ packages/python-crypto/trunk/debian/rules 2014-02-25 21:02:56 UTC (rev 27932)
@@ -14,7 +14,7 @@
override_dh_auto_build-indep:
pybuild --build -p $(shell pyversions -vd)
- pybuild -s custom --build \
+ pybuild -s custom --build -p $(shell pyversions -vd) \
--build-args="env PYTHONPATH={build_dir} epydoc --config Doc/epydoc-config"
override_dh_auto_test:
More information about the Python-modules-commits
mailing list