From 244469e3eb8ee0794a0db7413bc600e20ce22b4f Mon Sep 17 00:00:00 2001
From: Sergey Matveev <stargrave@stargrave.org>
Date: Thu, 2 May 2019 18:00:45 +0300
Subject: [PATCH] assertSequenceEqual gives more pretty output for human

---
 pygost/test_gost28147.py     | 47 +++++++++++++------------
 pygost/test_gost28147_mac.py | 12 +++----
 pygost/test_gost3410.py      |  8 ++---
 pygost/test_gost3410_vko.py  | 18 +++++-----
 pygost/test_gost34112012.py  | 26 +++++++-------
 pygost/test_gost341194.py    | 48 ++++++++++++-------------
 pygost/test_gost3412.py      | 68 ++++++++++++++++++------------------
 pygost/test_wrap.py          |  4 +--
 8 files changed, 116 insertions(+), 115 deletions(-)

diff --git a/pygost/test_gost28147.py b/pygost/test_gost28147.py
index 3e4298c..5928d6f 100644
--- a/pygost/test_gost28147.py
+++ b/pygost/test_gost28147.py
@@ -109,9 +109,9 @@ class ECBTest(TestCase):
             0x5a, 0x5f, 0xca, 0x58, 0x9a, 0xb2, 0x2d, 0xb2,
         )))
         encrypted = ecb_encrypt(key, plaintext, sbox=sbox)
-        self.assertEqual(encrypted, ciphertext)
+        self.assertSequenceEqual(encrypted, ciphertext)
         decrypted = ecb_decrypt(key, encrypted, sbox=sbox)
-        self.assertEqual(decrypted, plaintext)
+        self.assertSequenceEqual(decrypted, plaintext)
 
     def test_cryptopp(self):
         """ Test vectors from Crypto++ 5.6.2
@@ -131,14 +131,14 @@ class ECBTest(TestCase):
             key = hexdec(key)
             pt = hexdec(pt)
             ct = hexdec(ct)
-            self.assertEqual(ecb_encrypt(key, pt, sbox=sbox), ct)
+            self.assertSequenceEqual(ecb_encrypt(key, pt, sbox=sbox), ct)
 
     def test_cryptomanager(self):
         """ Test vector from http://cryptomanager.com/tv.html
         """
         sbox = "GostR3411_94_TestParamSet"
         key = hexdec(b"75713134B60FEC45A607BB83AA3746AF4FF99DA6D1B53B5B1B402A1BAA030D1B")
-        self.assertEqual(
+        self.assertSequenceEqual(
             ecb_encrypt(key, hexdec(b"1122334455667788"), sbox=sbox),
             hexdec(b"03251E14F9D28ACB"),
         )
@@ -150,7 +150,7 @@ class CFBTest(TestCase):
         """
         key = hexdec(b"75713134B60FEC45A607BB83AA3746AF4FF99DA6D1B53B5B1B402A1BAA030D1B")
         sbox = "GostR3411_94_TestParamSet"
-        self.assertEqual(
+        self.assertSequenceEqual(
             cfb_encrypt(
                 key,
                 hexdec(b"112233445566778899AABBCCDD800000"),
@@ -159,7 +159,7 @@ class CFBTest(TestCase):
             ),
             hexdec(b"6EE84586DD2BCA0CAD3616940E164242"),
         )
-        self.assertEqual(
+        self.assertSequenceEqual(
             cfb_decrypt(
                 key,
                 hexdec(b"6EE84586DD2BCA0CAD3616940E164242"),
@@ -180,17 +180,17 @@ class CFBTest(TestCase):
         # First full block
         step = encrypt(DEFAULT_SBOX, key, block2ns(iv))
         step = strxor(plaintext[:8], ns2block(step))
-        self.assertEqual(step, ciphertext[:8])
+        self.assertSequenceEqual(step, ciphertext[:8])
 
         # Second full block
         step = encrypt(DEFAULT_SBOX, key, block2ns(step))
         step = strxor(plaintext[8:16], ns2block(step))
-        self.assertEqual(step, ciphertext[8:16])
+        self.assertSequenceEqual(step, ciphertext[8:16])
 
         # Third non-full block
         step = encrypt(DEFAULT_SBOX, key, block2ns(step))
         step = strxor(plaintext[16:] + 4 * b"\x00", ns2block(step))
-        self.assertEqual(step[:4], ciphertext[16:])
+        self.assertSequenceEqual(step[:4], ciphertext[16:])
 
     def test_random(self):
         """ Random data with various sizes
@@ -199,8 +199,9 @@ class CFBTest(TestCase):
         iv = urandom(8)
         for size in (5, 8, 16, 120):
             pt = urandom(size)
-            self.assertEqual(
-                cfb_decrypt(key, cfb_encrypt(key, pt, iv), iv), pt,
+            self.assertSequenceEqual(
+                cfb_decrypt(key, cfb_encrypt(key, pt, iv), iv),
+                pt,
             )
 
 
@@ -280,9 +281,9 @@ class CTRTest(TestCase):
         )))
         iv = b"\x02\x01\x01\x01\x01\x01\x01\x01"
         encrypted = cnt(key, plaintext, iv=iv, sbox=sbox)
-        self.assertEqual(encrypted, ciphertext)
+        self.assertSequenceEqual(encrypted, ciphertext)
         decrypted = cnt(key, encrypted, iv=iv, sbox=sbox)
-        self.assertEqual(decrypted, plaintext)
+        self.assertSequenceEqual(decrypted, plaintext)
 
     def test_gcl2(self):
         """ Test vectors 2 from libgcl3
@@ -309,9 +310,9 @@ class CTRTest(TestCase):
         )))
         iv = 8 * b"\x00"
         encrypted = cnt(key, plaintext, iv=iv, sbox=sbox)
-        self.assertEqual(encrypted, ciphertext)
+        self.assertSequenceEqual(encrypted, ciphertext)
         decrypted = cnt(key, encrypted, iv=iv, sbox=sbox)
-        self.assertEqual(decrypted, plaintext)
+        self.assertSequenceEqual(decrypted, plaintext)
 
 
 class CBCTest(TestCase):
@@ -329,7 +330,7 @@ class CBCTest(TestCase):
         for pt in (b"foo", b"foobarba", b"foobarbaz", 16 * b"x"):
             ct = cbc_encrypt(key, pt, iv)
             dt = cbc_decrypt(key, ct)
-            self.assertEqual(pt, dt)
+            self.assertSequenceEqual(pt, dt)
 
     def test_iv_existence_check(self):
         key = 32 * b"x"
@@ -343,7 +344,7 @@ class CBCTest(TestCase):
         key = urandom(32)
         ct = cbc_encrypt(key, pt)
         dt = cbc_decrypt(key, ct)
-        self.assertEqual(pt, dt)
+        self.assertSequenceEqual(pt, dt)
 
 
 class CFBMeshingTest(TestCase):
@@ -355,28 +356,28 @@ class CFBMeshingTest(TestCase):
         pt = b"\x00"
         ct = cfb_encrypt(self.key, pt, mesh=True)
         dec = cfb_decrypt(self.key, ct, mesh=True)
-        self.assertEqual(pt, dec)
+        self.assertSequenceEqual(pt, dec)
 
     def test_short(self):
         pt = urandom(MESH_MAX_DATA - 1)
         ct = cfb_encrypt(self.key, pt, mesh=True)
         dec = cfb_decrypt(self.key, ct, mesh=True)
         dec_plain = cfb_decrypt(self.key, ct)
-        self.assertEqual(pt, dec)
-        self.assertEqual(pt, dec_plain)
+        self.assertSequenceEqual(pt, dec)
+        self.assertSequenceEqual(pt, dec_plain)
 
     def test_short_iv(self):
         pt = urandom(MESH_MAX_DATA - 1)
         ct = cfb_encrypt(self.key, pt, iv=self.iv, mesh=True)
         dec = cfb_decrypt(self.key, ct, iv=self.iv, mesh=True)
         dec_plain = cfb_decrypt(self.key, ct, iv=self.iv)
-        self.assertEqual(pt, dec)
-        self.assertEqual(pt, dec_plain)
+        self.assertSequenceEqual(pt, dec)
+        self.assertSequenceEqual(pt, dec_plain)
 
     def test_longer_iv(self):
         pt = urandom(MESH_MAX_DATA * 3)
         ct = cfb_encrypt(self.key, pt, iv=self.iv, mesh=True)
         dec = cfb_decrypt(self.key, ct, iv=self.iv, mesh=True)
         dec_plain = cfb_decrypt(self.key, ct, iv=self.iv)
-        self.assertEqual(pt, dec)
+        self.assertSequenceEqual(pt, dec)
         self.assertNotEqual(pt, dec_plain)
diff --git a/pygost/test_gost28147_mac.py b/pygost/test_gost28147_mac.py
index c8c0c84..98fd85c 100644
--- a/pygost/test_gost28147_mac.py
+++ b/pygost/test_gost28147_mac.py
@@ -26,25 +26,25 @@ class TestMAC(TestCase):
     k = b"This is message\xFF length\x0032 bytes"
 
     def test_a(self):
-        self.assertEqual(
+        self.assertSequenceEqual(
             MAC(self.k, b"a").hexdigest(),
             "bd5d3b5b2b7b57af",
         )
 
     def test_abc(self):
-        self.assertEqual(
+        self.assertSequenceEqual(
             MAC(self.k, b"abc").hexdigest(),
             "28661e40805b1ff9",
         )
 
     def test_128U(self):
-        self.assertEqual(
+        self.assertSequenceEqual(
             MAC(self.k, 128 * b"U").hexdigest(),
             "1a06d1bad74580ef",
         )
 
     def test_13x(self):
-        self.assertEqual(
+        self.assertSequenceEqual(
             MAC(self.k, 13 * b"x").hexdigest(),
             "917ee1f1a668fbd3",
         )
@@ -53,7 +53,7 @@ class TestMAC(TestCase):
         m = MAC(self.k)
         m.update(b"foo")
         m.update(b"bar")
-        self.assertEqual(m.digest(), MAC(self.k, b"foobar").digest())
+        self.assertSequenceEqual(m.digest(), MAC(self.k, b"foobar").digest())
 
     def test_copy(self):
         m = MAC(self.k, b"foo")
@@ -61,4 +61,4 @@ class TestMAC(TestCase):
         m.update(b"barbaz")
         c.update(b"bar")
         c.update(b"baz")
-        self.assertEqual(m.digest(), c.digest())
+        self.assertSequenceEqual(m.digest(), c.digest())
diff --git a/pygost/test_gost3410.py b/pygost/test_gost3410.py
index 736968b..972df82 100644
--- a/pygost/test_gost3410.py
+++ b/pygost/test_gost3410.py
@@ -70,8 +70,8 @@ class Test341001(TestCase):
 
         c = GOST3410Curve(*CURVE_PARAMS["GostR3410_2001_TestParamSet"])
         pubX, pubY = public_key(c, prv)
-        self.assertEqual(long2bytes(pubX), pub_x)
-        self.assertEqual(long2bytes(pubY), pub_y)
+        self.assertSequenceEqual(long2bytes(pubX), pub_x)
+        self.assertSequenceEqual(long2bytes(pubY), pub_y)
         s = sign(c, prv, digest)
         self.assertTrue(verify(c, (pubX, pubY), digest, s))
         self.assertTrue(verify(c, (pubX, pubY), digest, signature))
@@ -213,8 +213,8 @@ class Test34102012(TestCase):
 
         c = GOST3410Curve(p, q, a, b, x, y)
         pubX, pubY = public_key(c, prv)
-        self.assertEqual(long2bytes(pubX), pub_x)
-        self.assertEqual(long2bytes(pubY), pub_y)
+        self.assertSequenceEqual(long2bytes(pubX), pub_x)
+        self.assertSequenceEqual(long2bytes(pubY), pub_y)
         s = sign(c, prv, digest, mode=2012)
         self.assertTrue(verify(c, (pubX, pubY), digest, s, mode=2012))
         self.assertTrue(verify(c, (pubX, pubY), digest, signature, mode=2012))
diff --git a/pygost/test_gost3410_vko.py b/pygost/test_gost3410_vko.py
index 8ddd53b..7c44485 100644
--- a/pygost/test_gost3410_vko.py
+++ b/pygost/test_gost3410_vko.py
@@ -40,8 +40,8 @@ class TestVKO34102001(TestCase):
         kek = hexdec("ee4618a0dbb10cb31777b4b86a53d9e7ef6cb3e400101410f0c0f2af46c494a6")
         pub1 = public_key(curve, prv1)
         pub2 = public_key(curve, prv2)
-        self.assertEqual(kek_34102001(curve, prv1, pub2, ukm), kek)
-        self.assertEqual(kek_34102001(curve, prv2, pub1, ukm), kek)
+        self.assertSequenceEqual(kek_34102001(curve, prv1, pub2, ukm), kek)
+        self.assertSequenceEqual(kek_34102001(curve, prv2, pub1, ukm), kek)
 
     def test_sequence(self):
         curve = GOST3410Curve(*CURVE_PARAMS["GostR3410_2001_TestParamSet"])
@@ -53,7 +53,7 @@ class TestVKO34102001(TestCase):
             pub2 = public_key(curve, prv2)
             kek1 = kek_34102001(curve, prv1, pub2, ukm)
             kek2 = kek_34102001(curve, prv2, pub1, ukm)
-            self.assertEqual(kek1, kek2)
+            self.assertSequenceEqual(kek1, kek2)
             kek1 = kek_34102001(curve, prv1, pub1, ukm)
             kek2 = kek_34102001(curve, prv2, pub2, ukm)
             self.assertNotEqual(kek1, kek2)
@@ -70,8 +70,8 @@ class TestVKO34102012256(TestCase):
         prvB = prv_unmarshal(hexdec("48c859f7b6f11585887cc05ec6ef1390cfea739b1a18c0d4662293ef63b79e3b8014070b44918590b4b996acfea4edfbbbcccc8c06edd8bf5bda92a51392d0db"))
         pubB = pub_unmarshal(hexdec("192fe183b9713a077253c72c8735de2ea42a3dbc66ea317838b65fa32523cd5efca974eda7c863f4954d1147f1f2b25c395fce1c129175e876d132e94ed5a65104883b414c9b592ec4dc84826f07d0b6d9006dda176ce48c391e3f97d102e03bb598bf132a228a45f7201aba08fc524a2d77e43a362ab022ad4028f75bde3b79"), mode=2012)
         vko = hexdec("c9a9a77320e2cc559ed72dce6f47e2192ccea95fa648670582c054c0ef36c221")
-        self.assertEqual(kek_34102012256(curve, prvA, pubB, ukm), vko)
-        self.assertEqual(kek_34102012256(curve, prvB, pubA, ukm), vko)
+        self.assertSequenceEqual(kek_34102012256(curve, prvA, pubB, ukm), vko)
+        self.assertSequenceEqual(kek_34102012256(curve, prvB, pubA, ukm), vko)
 
     def test_sequence(self):
         curve = GOST3410Curve(*CURVE_PARAMS["GostR3410_2012_TC26_ParamSetA"])
@@ -83,7 +83,7 @@ class TestVKO34102012256(TestCase):
             pub2 = public_key(curve, prv2)
             kek1 = kek_34102012256(curve, prv1, pub2, ukm)
             kek2 = kek_34102012256(curve, prv2, pub1, ukm)
-            self.assertEqual(kek1, kek2)
+            self.assertSequenceEqual(kek1, kek2)
             kek1 = kek_34102012256(curve, prv1, pub1, ukm)
             kek2 = kek_34102012256(curve, prv2, pub2, ukm)
             self.assertNotEqual(kek1, kek2)
@@ -100,8 +100,8 @@ class TestVKO34102012512(TestCase):
         prvB = prv_unmarshal(hexdec("48c859f7b6f11585887cc05ec6ef1390cfea739b1a18c0d4662293ef63b79e3b8014070b44918590b4b996acfea4edfbbbcccc8c06edd8bf5bda92a51392d0db"))
         pubB = pub_unmarshal(hexdec("192fe183b9713a077253c72c8735de2ea42a3dbc66ea317838b65fa32523cd5efca974eda7c863f4954d1147f1f2b25c395fce1c129175e876d132e94ed5a65104883b414c9b592ec4dc84826f07d0b6d9006dda176ce48c391e3f97d102e03bb598bf132a228a45f7201aba08fc524a2d77e43a362ab022ad4028f75bde3b79"), mode=2012)
         vko = hexdec("79f002a96940ce7bde3259a52e015297adaad84597a0d205b50e3e1719f97bfa7ee1d2661fa9979a5aa235b558a7e6d9f88f982dd63fc35a8ec0dd5e242d3bdf")
-        self.assertEqual(kek_34102012512(curve, prvA, pubB, ukm), vko)
-        self.assertEqual(kek_34102012512(curve, prvB, pubA, ukm), vko)
+        self.assertSequenceEqual(kek_34102012512(curve, prvA, pubB, ukm), vko)
+        self.assertSequenceEqual(kek_34102012512(curve, prvB, pubA, ukm), vko)
 
     def test_sequence(self):
         curve = GOST3410Curve(*CURVE_PARAMS["GostR3410_2012_TC26_ParamSetA"])
@@ -113,7 +113,7 @@ class TestVKO34102012512(TestCase):
             pub2 = public_key(curve, prv2)
             kek1 = kek_34102012512(curve, prv1, pub2, ukm)
             kek2 = kek_34102012512(curve, prv2, pub1, ukm)
-            self.assertEqual(kek1, kek2)
+            self.assertSequenceEqual(kek1, kek2)
             kek1 = kek_34102012512(curve, prv1, pub1, ukm)
             kek2 = kek_34102012512(curve, prv2, pub2, ukm)
             self.assertNotEqual(kek1, kek2)
diff --git a/pygost/test_gost34112012.py b/pygost/test_gost34112012.py
index 14be493..5486d0e 100644
--- a/pygost/test_gost34112012.py
+++ b/pygost/test_gost34112012.py
@@ -35,7 +35,7 @@ class TestCopy(TestCase):
         m.update(b"foobar")
         c.update(b"foo")
         c.update(b"bar")
-        self.assertEqual(m.digest(), c.digest())
+        self.assertSequenceEqual(m.digest(), c.digest())
 
 
 class TestHMAC(TestCase):
@@ -43,7 +43,7 @@ class TestHMAC(TestCase):
     """
     def test_256(self):
         for digestmod in (GOST34112012256, gost34112012256):
-            self.assertEqual(
+            self.assertSequenceEqual(
                 hmac.new(
                     key=hexdec("000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f"),
                     msg=hexdec("0126bdb87800af214341456563780100"),
@@ -54,7 +54,7 @@ class TestHMAC(TestCase):
 
     def test_512(self):
         for digestmod in (GOST34112012512, gost34112012512):
-            self.assertEqual(
+            self.assertSequenceEqual(
                 hmac.new(
                     key=hexdec("000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f"),
                     msg=hexdec("0126bdb87800af214341456563780100"),
@@ -67,11 +67,11 @@ class TestHMAC(TestCase):
 class TestVectors(TestCase):
     def test_m1(self):
         m = hexdec("323130393837363534333231303938373635343332313039383736353433323130393837363534333231303938373635343332313039383736353433323130")[::-1]
-        self.assertEqual(
+        self.assertSequenceEqual(
             GOST34112012512(m).digest(),
             hexdec("486f64c1917879417fef082b3381a4e211c324f074654c38823a7b76f830ad00fa1fbae42b1285c0352f227524bc9ab16254288dd6863dccd5b9f54a1ad0541b")[::-1]
         )
-        self.assertEqual(
+        self.assertSequenceEqual(
             GOST34112012256(m).digest(),
             hexdec("00557be5e584fd52a449b16b0251d05d27f94ab76cbaa6da890b59d8ef1e159d")[::-1]
         )
@@ -79,11 +79,11 @@ class TestVectors(TestCase):
     def test_m2(self):
         m = u"Се ветри, Стрибожи внуци, веютъ с моря стрелами на храбрыя плъкы Игоревы".encode("cp1251")
         self.assertSequenceEqual(m, hexdec("fbe2e5f0eee3c820fbeafaebef20fffbf0e1e0f0f520e0ed20e8ece0ebe5f0f2f120fff0eeec20f120faf2fee5e2202ce8f6f3ede220e8e6eee1e8f0f2d1202ce8f0f2e5e220e5d1")[::-1])
-        self.assertEqual(
+        self.assertSequenceEqual(
             GOST34112012512(m).digest(),
             hexdec("28fbc9bada033b1460642bdcddb90c3fb3e56c497ccd0f62b8a2ad4935e85f037613966de4ee00531ae60f3b5a47f8dae06915d5f2f194996fcabf2622e6881e")[::-1]
         )
-        self.assertEqual(
+        self.assertSequenceEqual(
             GOST34112012256(m).digest(),
             hexdec("508f7e553c06501d749a66fc28c6cac0b005746d97537fa85d9e40904efed29d")[::-1]
         )
@@ -101,32 +101,32 @@ class TestPBKDF2(TestCase):
     """http://tc26.ru/.../R_50.1.111-2016.pdf
     """
     def test_1(self):
-        self.assertEqual(
+        self.assertSequenceEqual(
             hexenc(pbkdf2(b"password", b"salt", 1, 64)),
             "64770af7f748c3b1c9ac831dbcfd85c26111b30a8a657ddc3056b80ca73e040d2854fd36811f6d825cc4ab66ec0a68a490a9e5cf5156b3a2b7eecddbf9a16b47",
         )
 
     def test_2(self):
-        self.assertEqual(
+        self.assertSequenceEqual(
             hexenc(pbkdf2(b"password", b"salt", 2, 64)),
             "5a585bafdfbb6e8830d6d68aa3b43ac00d2e4aebce01c9b31c2caed56f0236d4d34b2b8fbd2c4e89d54d46f50e47d45bbac301571743119e8d3c42ba66d348de",
         )
 
     def test_3(self):
-        self.assertEqual(
+        self.assertSequenceEqual(
             hexenc(pbkdf2(b"password", b"salt", 4096, 64)),
             "e52deb9a2d2aaff4e2ac9d47a41f34c20376591c67807f0477e32549dc341bc7867c09841b6d58e29d0347c996301d55df0d34e47cf68f4e3c2cdaf1d9ab86c3",
         )
 
     @skip("it takes too long")
     def test_4(self):
-        self.assertEqual(
+        self.assertSequenceEqual(
             hexenc(pbkdf2(b"password", b"salt", 1677216, 64)),
             "49e4843bba76e300afe24c4d23dc7392def12f2c0e244172367cd70a8982ac361adb601c7e2a314e8cb7b1e9df840e36ab5615be5d742b6cf203fb55fdc48071",
         )
 
     def test_5(self):
-        self.assertEqual(
+        self.assertSequenceEqual(
             hexenc(pbkdf2(
                 b"passwordPASSWORDpassword",
                 b"saltSALTsaltSALTsaltSALTsaltSALTsalt",
@@ -137,7 +137,7 @@ class TestPBKDF2(TestCase):
         )
 
     def test_6(self):
-        self.assertEqual(
+        self.assertSequenceEqual(
             hexenc(pbkdf2(b"pass\x00word", b"sa\x00lt", 4096, 64)),
             "50df062885b69801a3c10248eb0a27ab6e522ffeb20c991c660f001475d73a4e167f782c18e97e92976d9c1d970831ea78ccb879f67068cdac1910740844e830",
         )
diff --git a/pygost/test_gost341194.py b/pygost/test_gost341194.py
index 55a3597..cb98c26 100644
--- a/pygost/test_gost341194.py
+++ b/pygost/test_gost341194.py
@@ -32,7 +32,7 @@ class TestCopy(TestCase):
         m.update(b"foobar")
         c.update(b"foo")
         c.update(b"bar")
-        self.assertEqual(m.digest(), c.digest())
+        self.assertSequenceEqual(m.digest(), c.digest())
 
 
 class TestHMACPEP247(TestCase):
@@ -44,55 +44,55 @@ class TestHMACPEP247(TestCase):
 
 class TestVectors(TestCase):
     def test_empty(self):
-        self.assertEqual(
+        self.assertSequenceEqual(
             GOST341194(b"", "GostR3411_94_TestParamSet").hexdigest(),
             "ce85b99cc46752fffee35cab9a7b0278abb4c2d2055cff685af4912c49490f8d",
         )
 
     def test_a(self):
-        self.assertEqual(
+        self.assertSequenceEqual(
             GOST341194(b"a", "GostR3411_94_TestParamSet").hexdigest(),
             "d42c539e367c66e9c88a801f6649349c21871b4344c6a573f849fdce62f314dd",
         )
 
     def test_abc(self):
-        self.assertEqual(
+        self.assertSequenceEqual(
             GOST341194(b"abc", "GostR3411_94_TestParamSet").hexdigest(),
             "f3134348c44fb1b2a277729e2285ebb5cb5e0f29c975bc753b70497c06a4d51d",
         )
 
     def test_message_digest(self):
-        self.assertEqual(
+        self.assertSequenceEqual(
             GOST341194(b"message digest", "GostR3411_94_TestParamSet").hexdigest(),
             "ad4434ecb18f2c99b60cbe59ec3d2469582b65273f48de72db2fde16a4889a4d",
         )
 
     def test_Us(self):
-        self.assertEqual(
+        self.assertSequenceEqual(
             GOST341194(128 * b"U", "GostR3411_94_TestParamSet").hexdigest(),
             "53a3a3ed25180cef0c1d85a074273e551c25660a87062a52d926a9e8fe5733a4",
         )
 
     def test_dog(self):
-        self.assertEqual(
+        self.assertSequenceEqual(
             GOST341194(b"The quick brown fox jumps over the lazy dog", "GostR3411_94_TestParamSet",).hexdigest(),
             "77b7fa410c9ac58a25f49bca7d0468c9296529315eaca76bd1a10f376d1f4294",
         )
 
     def test_cog(self):
-        self.assertEqual(
+        self.assertSequenceEqual(
             GOST341194(b"The quick brown fox jumps over the lazy cog", "GostR3411_94_TestParamSet",).hexdigest(),
             "a3ebc4daaab78b0be131dab5737a7f67e602670d543521319150d2e14eeec445",
         )
 
     def test_rfc32(self):
-        self.assertEqual(
+        self.assertSequenceEqual(
             GOST341194(b"This is message, length=32 bytes", "GostR3411_94_TestParamSet",).hexdigest(),
             "b1c466d37519b82e8319819ff32595e047a28cb6f83eff1c6916a815a637fffa",
         )
 
     def test_rfc50(self):
-        self.assertEqual(
+        self.assertSequenceEqual(
             GOST341194(b"Suppose the original message has length = 50 bytes", "GostR3411_94_TestParamSet",).hexdigest(),
             "471aba57a60a770d3a76130635c1fbea4ef14de51f78b4ae57dd893b62f55208",
         )
@@ -102,49 +102,49 @@ class TestVectorsCryptoPro(TestCase):
     """ CryptoPro S-box test vectors
     """
     def test_empty(self):
-        self.assertEqual(
+        self.assertSequenceEqual(
             GOST341194(b"", "GostR3411_94_CryptoProParamSet").hexdigest(),
             "981e5f3ca30c841487830f84fb433e13ac1101569b9c13584ac483234cd656c0",
         )
 
     def test_a(self):
-        self.assertEqual(
+        self.assertSequenceEqual(
             GOST341194(b"a", "GostR3411_94_CryptoProParamSet").hexdigest(),
             "e74c52dd282183bf37af0079c9f78055715a103f17e3133ceff1aacf2f403011",
         )
 
     def test_abc(self):
-        self.assertEqual(
+        self.assertSequenceEqual(
             GOST341194(b"abc", "GostR3411_94_CryptoProParamSet").hexdigest(),
             "b285056dbf18d7392d7677369524dd14747459ed8143997e163b2986f92fd42c",
         )
 
     def test_message_digest(self):
-        self.assertEqual(
+        self.assertSequenceEqual(
             GOST341194(b"message digest", "GostR3411_94_CryptoProParamSet",).hexdigest(),
             "bc6041dd2aa401ebfa6e9886734174febdb4729aa972d60f549ac39b29721ba0",
         )
 
     def test_dog(self):
-        self.assertEqual(
+        self.assertSequenceEqual(
             GOST341194(b"The quick brown fox jumps over the lazy dog", "GostR3411_94_CryptoProParamSet",).hexdigest(),
             "9004294a361a508c586fe53d1f1b02746765e71b765472786e4770d565830a76",
         )
 
     def test_32(self):
-        self.assertEqual(
+        self.assertSequenceEqual(
             GOST341194(b"This is message, length=32 bytes", "GostR3411_94_CryptoProParamSet",).hexdigest(),
             "2cefc2f7b7bdc514e18ea57fa74ff357e7fa17d652c75f69cb1be7893ede48eb",
         )
 
     def test_50(self):
-        self.assertEqual(
+        self.assertSequenceEqual(
             GOST341194(b"Suppose the original message has length = 50 bytes", "GostR3411_94_CryptoProParamSet",).hexdigest(),
             "c3730c5cbccacf915ac292676f21e8bd4ef75331d9405e5f1a61dc3130a65011",
         )
 
     def test_Us(self):
-        self.assertEqual(
+        self.assertSequenceEqual(
             GOST341194(128 * b"U", "GostR3411_94_CryptoProParamSet").hexdigest(),
             "1c4ac7614691bbf427fa2316216be8f10d92edfd37cd1027514c1008f649c4e8",
         )
@@ -154,32 +154,32 @@ class TestPBKDF2(TestCase):
     """http://tc26.ru/methods/containers_v1/Addition_to_PKCS5_v1_0.pdf test vectors
     """
     def test_1(self):
-        self.assertEqual(
+        self.assertSequenceEqual(
             hexenc(pbkdf2(b"password", b"salt", 1, 32)),
             "7314e7c04fb2e662c543674253f68bd0b73445d07f241bed872882da21662d58",
         )
 
     def test_2(self):
-        self.assertEqual(
+        self.assertSequenceEqual(
             hexenc(pbkdf2(b"password", b"salt", 2, 32)),
             "990dfa2bd965639ba48b07b792775df79f2db34fef25f274378872fed7ed1bb3",
         )
 
     def test_3(self):
-        self.assertEqual(
+        self.assertSequenceEqual(
             hexenc(pbkdf2(b"password", b"salt", 4096, 32)),
             "1f1829a94bdff5be10d0aeb36af498e7a97467f3b31116a5a7c1afff9deadafe",
         )
 
     @skip("it takes too long")
     def test_4(self):
-        self.assertEqual(
+        self.assertSequenceEqual(
             hexenc(pbkdf2(b"password", b"salt", 16777216, 32)),
             "a57ae5a6088396d120850c5c09de0a525100938a59b1b5c3f7810910d05fcd97",
         )
 
     def test_5(self):
-        self.assertEqual(
+        self.assertSequenceEqual(
             hexenc(pbkdf2(
                 b"passwordPASSWORDpassword",
                 b"saltSALTsaltSALTsaltSALTsaltSALTsalt",
@@ -190,7 +190,7 @@ class TestPBKDF2(TestCase):
         )
 
     def test_6(self):
-        self.assertEqual(
+        self.assertSequenceEqual(
             hexenc(pbkdf2(
                 b"pass\x00word",
                 b"sa\x00lt",
diff --git a/pygost/test_gost3412.py b/pygost/test_gost3412.py
index f54f418..cbf28e8 100644
--- a/pygost/test_gost3412.py
+++ b/pygost/test_gost3412.py
@@ -36,55 +36,55 @@ def R(blk):
 class STest(TestCase):
     def test_vec1(self):
         blk = bytearray(hexdec("ffeeddccbbaa99881122334455667700"))
-        self.assertEqual(S(blk), hexdec("b66cd8887d38e8d77765aeea0c9a7efc"))
+        self.assertSequenceEqual(S(blk), hexdec("b66cd8887d38e8d77765aeea0c9a7efc"))
 
     def test_vec2(self):
         blk = bytearray(hexdec("b66cd8887d38e8d77765aeea0c9a7efc"))
-        self.assertEqual(S(blk), hexdec("559d8dd7bd06cbfe7e7b262523280d39"))
+        self.assertSequenceEqual(S(blk), hexdec("559d8dd7bd06cbfe7e7b262523280d39"))
 
     def test_vec3(self):
         blk = bytearray(hexdec("559d8dd7bd06cbfe7e7b262523280d39"))
-        self.assertEqual(S(blk), hexdec("0c3322fed531e4630d80ef5c5a81c50b"))
+        self.assertSequenceEqual(S(blk), hexdec("0c3322fed531e4630d80ef5c5a81c50b"))
 
     def test_vec4(self):
         blk = bytearray(hexdec("0c3322fed531e4630d80ef5c5a81c50b"))
-        self.assertEqual(S(blk), hexdec("23ae65633f842d29c5df529c13f5acda"))
+        self.assertSequenceEqual(S(blk), hexdec("23ae65633f842d29c5df529c13f5acda"))
 
 
 class RTest(TestCase):
     def test_vec1(self):
         blk = bytearray(hexdec("00000000000000000000000000000100"))
-        self.assertEqual(R(blk), hexdec("94000000000000000000000000000001"))
+        self.assertSequenceEqual(R(blk), hexdec("94000000000000000000000000000001"))
 
     def test_vec2(self):
         blk = bytearray(hexdec("94000000000000000000000000000001"))
-        self.assertEqual(R(blk), hexdec("a5940000000000000000000000000000"))
+        self.assertSequenceEqual(R(blk), hexdec("a5940000000000000000000000000000"))
 
     def test_vec3(self):
         blk = bytearray(hexdec("a5940000000000000000000000000000"))
-        self.assertEqual(R(blk), hexdec("64a59400000000000000000000000000"))
+        self.assertSequenceEqual(R(blk), hexdec("64a59400000000000000000000000000"))
 
     def test_vec4(self):
         blk = bytearray(hexdec("64a59400000000000000000000000000"))
-        self.assertEqual(R(blk), hexdec("0d64a594000000000000000000000000"))
+        self.assertSequenceEqual(R(blk), hexdec("0d64a594000000000000000000000000"))
 
 
 class LTest(TestCase):
     def test_vec1(self):
         blk = bytearray(hexdec("64a59400000000000000000000000000"))
-        self.assertEqual(L(blk), hexdec("d456584dd0e3e84cc3166e4b7fa2890d"))
+        self.assertSequenceEqual(L(blk), hexdec("d456584dd0e3e84cc3166e4b7fa2890d"))
 
     def test_vec2(self):
         blk = bytearray(hexdec("d456584dd0e3e84cc3166e4b7fa2890d"))
-        self.assertEqual(L(blk), hexdec("79d26221b87b584cd42fbc4ffea5de9a"))
+        self.assertSequenceEqual(L(blk), hexdec("79d26221b87b584cd42fbc4ffea5de9a"))
 
     def test_vec3(self):
         blk = bytearray(hexdec("79d26221b87b584cd42fbc4ffea5de9a"))
-        self.assertEqual(L(blk), hexdec("0e93691a0cfc60408b7b68f66b513c13"))
+        self.assertSequenceEqual(L(blk), hexdec("0e93691a0cfc60408b7b68f66b513c13"))
 
     def test_vec4(self):
         blk = bytearray(hexdec("0e93691a0cfc60408b7b68f66b513c13"))
-        self.assertEqual(L(blk), hexdec("e6a8094fee0aa204fd97bcb0b44b8580"))
+        self.assertSequenceEqual(L(blk), hexdec("e6a8094fee0aa204fd97bcb0b44b8580"))
 
 
 class KuznechikTest(TestCase):
@@ -93,35 +93,35 @@ class KuznechikTest(TestCase):
     ciphertext = hexdec("7f679d90bebc24305a468d42b9d4edcd")
 
     def test_c(self):
-        self.assertEqual(C[0], hexdec("6ea276726c487ab85d27bd10dd849401"))
-        self.assertEqual(C[1], hexdec("dc87ece4d890f4b3ba4eb92079cbeb02"))
-        self.assertEqual(C[2], hexdec("b2259a96b4d88e0be7690430a44f7f03"))
-        self.assertEqual(C[3], hexdec("7bcd1b0b73e32ba5b79cb140f2551504"))
-        self.assertEqual(C[4], hexdec("156f6d791fab511deabb0c502fd18105"))
-        self.assertEqual(C[5], hexdec("a74af7efab73df160dd208608b9efe06"))
-        self.assertEqual(C[6], hexdec("c9e8819dc73ba5ae50f5b570561a6a07"))
-        self.assertEqual(C[7], hexdec("f6593616e6055689adfba18027aa2a08"))
+        self.assertSequenceEqual(C[0], hexdec("6ea276726c487ab85d27bd10dd849401"))
+        self.assertSequenceEqual(C[1], hexdec("dc87ece4d890f4b3ba4eb92079cbeb02"))
+        self.assertSequenceEqual(C[2], hexdec("b2259a96b4d88e0be7690430a44f7f03"))
+        self.assertSequenceEqual(C[3], hexdec("7bcd1b0b73e32ba5b79cb140f2551504"))
+        self.assertSequenceEqual(C[4], hexdec("156f6d791fab511deabb0c502fd18105"))
+        self.assertSequenceEqual(C[5], hexdec("a74af7efab73df160dd208608b9efe06"))
+        self.assertSequenceEqual(C[6], hexdec("c9e8819dc73ba5ae50f5b570561a6a07"))
+        self.assertSequenceEqual(C[7], hexdec("f6593616e6055689adfba18027aa2a08"))
 
     def test_roundkeys(self):
         ciph = GOST3412Kuznechik(self.key)
-        self.assertEqual(ciph.ks[0], hexdec("8899aabbccddeeff0011223344556677"))
-        self.assertEqual(ciph.ks[1], hexdec("fedcba98765432100123456789abcdef"))
-        self.assertEqual(ciph.ks[2], hexdec("db31485315694343228d6aef8cc78c44"))
-        self.assertEqual(ciph.ks[3], hexdec("3d4553d8e9cfec6815ebadc40a9ffd04"))
-        self.assertEqual(ciph.ks[4], hexdec("57646468c44a5e28d3e59246f429f1ac"))
-        self.assertEqual(ciph.ks[5], hexdec("bd079435165c6432b532e82834da581b"))
-        self.assertEqual(ciph.ks[6], hexdec("51e640757e8745de705727265a0098b1"))
-        self.assertEqual(ciph.ks[7], hexdec("5a7925017b9fdd3ed72a91a22286f984"))
-        self.assertEqual(ciph.ks[8], hexdec("bb44e25378c73123a5f32f73cdb6e517"))
-        self.assertEqual(ciph.ks[9], hexdec("72e9dd7416bcf45b755dbaa88e4a4043"))
+        self.assertSequenceEqual(ciph.ks[0], hexdec("8899aabbccddeeff0011223344556677"))
+        self.assertSequenceEqual(ciph.ks[1], hexdec("fedcba98765432100123456789abcdef"))
+        self.assertSequenceEqual(ciph.ks[2], hexdec("db31485315694343228d6aef8cc78c44"))
+        self.assertSequenceEqual(ciph.ks[3], hexdec("3d4553d8e9cfec6815ebadc40a9ffd04"))
+        self.assertSequenceEqual(ciph.ks[4], hexdec("57646468c44a5e28d3e59246f429f1ac"))
+        self.assertSequenceEqual(ciph.ks[5], hexdec("bd079435165c6432b532e82834da581b"))
+        self.assertSequenceEqual(ciph.ks[6], hexdec("51e640757e8745de705727265a0098b1"))
+        self.assertSequenceEqual(ciph.ks[7], hexdec("5a7925017b9fdd3ed72a91a22286f984"))
+        self.assertSequenceEqual(ciph.ks[8], hexdec("bb44e25378c73123a5f32f73cdb6e517"))
+        self.assertSequenceEqual(ciph.ks[9], hexdec("72e9dd7416bcf45b755dbaa88e4a4043"))
 
     def test_encrypt(self):
         ciph = GOST3412Kuznechik(self.key)
-        self.assertEqual(ciph.encrypt(self.plaintext), self.ciphertext)
+        self.assertSequenceEqual(ciph.encrypt(self.plaintext), self.ciphertext)
 
     def test_decrypt(self):
         ciph = GOST3412Kuznechik(self.key)
-        self.assertEqual(ciph.decrypt(self.ciphertext), self.plaintext)
+        self.assertSequenceEqual(ciph.decrypt(self.ciphertext), self.plaintext)
 
 
 class MagmaTest(TestCase):
@@ -131,8 +131,8 @@ class MagmaTest(TestCase):
 
     def test_encrypt(self):
         ciph = GOST3412Magma(self.key)
-        self.assertEqual(ciph.encrypt(self.plaintext), self.ciphertext)
+        self.assertSequenceEqual(ciph.encrypt(self.plaintext), self.ciphertext)
 
     def test_decrypt(self):
         ciph = GOST3412Magma(self.key)
-        self.assertEqual(ciph.decrypt(self.ciphertext), self.plaintext)
+        self.assertSequenceEqual(ciph.decrypt(self.ciphertext), self.plaintext)
diff --git a/pygost/test_wrap.py b/pygost/test_wrap.py
index 3e57e24..e419a8e 100644
--- a/pygost/test_wrap.py
+++ b/pygost/test_wrap.py
@@ -32,7 +32,7 @@ class WrapGostTest(TestCase):
             ukm = urandom(8)
             wrapped = wrap_gost(ukm, kek, cek)
             unwrapped = unwrap_gost(kek, wrapped)
-            self.assertEqual(unwrapped, cek)
+            self.assertSequenceEqual(unwrapped, cek)
 
     def test_invalid_length(self):
         with self.assertRaises(ValueError):
@@ -49,4 +49,4 @@ class WrapCryptoproTest(TestCase):
             ukm = urandom(8)
             wrapped = wrap_cryptopro(ukm, kek, cek)
             unwrapped = unwrap_cryptopro(kek, wrapped)
-            self.assertEqual(unwrapped, cek)
+            self.assertSequenceEqual(unwrapped, cek)
-- 
2.44.0