Use more assertSequenceEqual

For binary/text sequences it gives much more prettier output when
failing, more convenient and easy for human to deal with.

diff --git a/pyac/tests/test_blob.py b/pyac/tests/test_blob.py
index 08cd5b64230d0c3aa0da036214fa85437f899f9138e503221e3af0926b0bff9b..697a8bee99127163a28b368eae309f0a3a8712f6b4682bb9c1b05ce9ffdcfeff 100644 (file)
--- a/pyac/tests/test_blob.py
+++ b/pyac/tests/test_blob.py
@@ -14,7 +14,7 @@ class TestBlob(TestCase):
     def test_blob_encode(self) -> None:
         blob = Blob(4, b"testdata")
         encoded = dumps(blob)
-        self.assertEqual(
+        self.assertSequenceEqual(
             encoded, b"\x0b\x00\x00\x00\x00\x00\x00\x00\x03\x01test\x01data\x80"
         )
 
@@ -23,8 +23,8 @@ class TestBlob(TestCase):
         encoded = b"\x0B\x00\x00\x00\x00\x00\x00\x00\x03\x01test\x01data\x80" + junk
         decoded, tail = loads(encoded)
         self.assertEqual(decoded.l, 4)
-        self.assertEqual(decoded.v, b"testdata")
-        self.assertEqual(tail, junk)
+        self.assertSequenceEqual(decoded.v, b"testdata")
+        self.assertSequenceEqual(tail, junk)
 
     def test_throws_when_not_enough_data(self) -> None:
         encoded = b"\x0B\x00\x00\x00\x00\x00\x00\x00\x03\x01test\x01da"

diff --git a/pyac/tests/test_bool.py b/pyac/tests/test_bool.py
index f084eb81114df9a5dd993cf33977fd53860986ab95f3f6b41ff4de17c1687c4b..baa7dcddedd25681558d86d7e8b526b04896ce2aa9fc1789963e9b4b72e45fde 100644 (file)
--- a/pyac/tests/test_bool.py
+++ b/pyac/tests/test_bool.py
@@ -21,11 +21,11 @@ class TestBool(TestCase):
         encoded = b"\x03" + junk
         decoded, tail = loads(encoded)
         self.assertIs(decoded, True)
-        self.assertEqual(tail, junk)
+        self.assertSequenceEqual(tail, junk)
 
     @given(junk_st)
     def test_bool_decode_false(self, junk):
         encoded = b"\x02" + junk
         decoded, tail = loads(encoded)
         self.assertIs(decoded, False)
-        self.assertEqual(tail, junk)
+        self.assertSequenceEqual(tail, junk)

diff --git a/pyac/tests/test_float.py b/pyac/tests/test_float.py
index 61699d68693b55f74fa026d42c6a5d91e7acc08df7a3c0acc4e42976ee5ba6c2..17197f42046914160ce9df5c0a9a42832efe06414321f6da5350a612f81be517 100644 (file)
--- a/pyac/tests/test_float.py
+++ b/pyac/tests/test_float.py
@@ -30,8 +30,8 @@ class TestFloat(TestCase):
         ]
         for _float, expected in zip(floats, expecteds):
             decoded, tail = loads(_float)
-            self.assertEqual(decoded, expected)
-            self.assertEqual(tail, b"")
+            self.assertSequenceEqual(decoded, expected)
+            self.assertSequenceEqual(tail, b"")
 
     def test_float_not_enough_data(self) -> None:
         floats: List[bytes] = [

diff --git a/pyac/tests/test_int.py b/pyac/tests/test_int.py
index 5c4b819eb64b2548f67cfa9cd915a56b6d801974b0b3775f9b63b1b8f897404a..145bb4290f08fa1d3c818c717b29fead576b1728a9f49151b8b305bea5ad30b9 100644 (file)
--- a/pyac/tests/test_int.py
+++ b/pyac/tests/test_int.py
@@ -16,10 +16,10 @@ class TestInt(TestCase):
             b"\x0c\x91\x04\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00",
         ]
         for integer, encoded in zip(ints, expected):
-            self.assertEqual(dumps(integer), encoded)
+            self.assertSequenceEqual(dumps(integer), encoded)
             decoded, tail = loads(encoded)
             self.assertEqual(decoded, integer)
-            self.assertEqual(tail, b"")
+            self.assertSequenceEqual(tail, b"")
 
     def test_int_negative(self) -> None:
         ints: list[int] = [-1, -123, -(1 << 64), -(1 << 130)]
@@ -30,17 +30,17 @@ class TestInt(TestCase):
             b"\x0D\x91\x03\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff",
         ]
         for integer, encoded in zip(ints, expected):
-            self.assertEqual(dumps(integer), encoded)
+            self.assertSequenceEqual(dumps(integer), encoded)
             decoded, tail = loads(encoded)
             self.assertEqual(decoded, integer)
-            self.assertEqual(tail, b"")
+            self.assertSequenceEqual(tail, b"")
 
     def test_int_zero(self) -> None:
         encoded: bytes = dumps(0)
-        self.assertEqual(encoded, b"\x0C\x80")
+        self.assertSequenceEqual(encoded, b"\x0C\x80")
         decoded, tail = loads(encoded)
         self.assertEqual(decoded, 0)
-        self.assertEqual(tail, b"")
+        self.assertSequenceEqual(tail, b"")
 
     def test_int_decode_not_enough_data(self) -> None:
         encoded: bytes = b"\x0C\x81"

diff --git a/pyac/tests/test_list.py b/pyac/tests/test_list.py
index 317f978d004d7cf821f7538127f50db31872d056beb5683660399fac1c5ec924..3b102a15ab269404feee9244b69fa9889264df28daefe9e0f55d786fe8fc012f 100644 (file)
--- a/pyac/tests/test_list.py
+++ b/pyac/tests/test_list.py
@@ -14,12 +14,12 @@ from tests.strategies import junk_st
 class TestList(TestCase):
     def test_list_encode_empty(self) -> None:
         encoded = dumps([])
-        self.assertEqual(encoded, b"\x08\x00")
+        self.assertSequenceEqual(encoded, b"\x08\x00")
 
     @given(lists(any_st, max_size=4))
     def test_list_encode_non_empty(self, test_list: List) -> None:
         encoded = dumps(test_list)
-        self.assertEqual(
+        self.assertSequenceEqual(
             encoded, b"\x08" + b"".join(dumps(i) for i in test_list) + b"\x00"
         )
 
@@ -27,14 +27,14 @@ class TestList(TestCase):
         encoded = b"\x08\x00"
         decoded, tail = loads(encoded)
         self.assertEqual(decoded, [])
-        self.assertEqual(tail, b"")
+        self.assertSequenceEqual(tail, b"")
 
     @given(lists(any_st, max_size=4), junk_st)
     def test_list_decode_non_empty(self, test_list: List, junk: bytes) -> None:
         encoded = b"\x08" + b"".join(dumps(i) for i in test_list) + b"\x00" + junk
         decoded, tail = loads(encoded)
         self.assertEqual(decoded, test_list)
-        self.assertEqual(tail, junk)
+        self.assertSequenceEqual(tail, junk)
 
     @given(lists(any_st, max_size=4))
     def test_no_eoc(self, test_list: List) -> None:

diff --git a/pyac/tests/test_map.py b/pyac/tests/test_map.py
index 4b17f692a4bfc213e590655b35a8cbfdb43943670c81824df8781bb3ae6c497e..89c41b45f2598d09ce12e6a3e50be5aae033a03efd6a3c380bc6132944dad02f 100644 (file)
--- a/pyac/tests/test_map.py
+++ b/pyac/tests/test_map.py
@@ -26,7 +26,7 @@ class TestMap(TestCase):
             ) +
             b"\x00"
         )
-        self.assertEqual(encoded, expected)
+        self.assertSequenceEqual(encoded, expected)
 
     @given(dictionaries(keys=mapkey_st, values=any_st, max_size=4), junk_st)
     def test_map_decode(self, test_map, junk):
@@ -43,17 +43,17 @@ class TestMap(TestCase):
         )
         decoded, tail = loads(encoded)
         self.assertEqual(decoded, test_map)
-        self.assertEqual(tail, junk)
+        self.assertSequenceEqual(tail, junk)
 
     @given(junk_st)
     def test_map_empty(self, junk):
         test_map = {}
         encoded = dumps(test_map) + junk
         expected = b"\x09\x00" + junk
-        self.assertEqual(encoded, expected)
+        self.assertSequenceEqual(encoded, expected)
         decoded, tail = loads(encoded)
         self.assertEqual(decoded, test_map)
-        self.assertEqual(tail, junk)
+        self.assertSequenceEqual(tail, junk)
 
     @given(lists(mapkey_st, max_size=4), junk_st)
     def test_decode_to_set(self, keys, junk):
@@ -61,7 +61,7 @@ class TestMap(TestCase):
         encoded = dumps(test_map) + junk
         decoded, tail = loads(encoded, sets=True)
         self.assertEqual(decoded, set(keys))
-        self.assertEqual(tail, junk)
+        self.assertSequenceEqual(tail, junk)
 
     def test_map_throws_when_decoding_unsorted_keys(self):
         encoded = b"\x09\xc4key2\x0c\x81\x01\xc4key1\xc6value1\x00"

diff --git a/pyac/tests/test_str.py b/pyac/tests/test_str.py
index 9a92f9f63a1fa96a0aec2167d70463505e54fce15ab5942b24b3e4037080aba2..d51d733ae83053daa57ae7321b4e2b51e7150e10e76b982d7b2518ecf3c0f6c3 100644 (file)
--- a/pyac/tests/test_str.py
+++ b/pyac/tests/test_str.py
@@ -32,31 +32,31 @@ class TestString(TestCase):
             return
         encoded = dumps(test_str)
         tag = (TagStr | TagUTF8 | len(test_str.encode("utf-8"))).to_bytes(1, "big")
-        self.assertEqual(encoded, tag + test_str.encode("utf-8"))
+        self.assertSequenceEqual(encoded, tag + test_str.encode("utf-8"))
 
     def test_long_utf8(self) -> None:
         long_strings = ["a" * 62, "a" * 318, "a" * 65853]
         for long_string in long_strings:
             encoded = dumps(long_string)
             decoded, tail = loads(encoded)
-            self.assertEqual(decoded, long_string)
-            self.assertEqual(tail, b"")
+            self.assertSequenceEqual(decoded, long_string)
+            self.assertSequenceEqual(tail, b"")
 
     def test_encode_non_utf8(self) -> None:
         bs = b"\x00\x01\x02"
         encoded = dumps(bs)
-        self.assertEqual(encoded, b"\x83\x00\x01\x02")
+        self.assertSequenceEqual(encoded, b"\x83\x00\x01\x02")
         decoded, tail = loads(encoded)
-        self.assertEqual(decoded, b"\x00\x01\x02")
-        self.assertEqual(tail, b"")
+        self.assertSequenceEqual(decoded, b"\x00\x01\x02")
+        self.assertSequenceEqual(tail, b"")
 
     def test_long_non_utf8(self) -> None:
         long_bss = [b"\x01" * 62, b"\x01" * 318, b"\x01" * 65853]
         for long_bs in long_bss:
             encoded = dumps(long_bs)
             decoded, tail = loads(encoded)
-            self.assertEqual(decoded, long_bs)
-            self.assertEqual(tail, b"")
+            self.assertSequenceEqual(decoded, long_bs)
+            self.assertSequenceEqual(tail, b"")
 
     def test_throws_when_not_enough_data(self) -> None:
         encoded = b"\x85he"

diff --git a/pyac/tests/test_tai.py b/pyac/tests/test_tai.py
index 3c139ae23254d46790b58ae7fb9a4cb765e7531790492ee58d4aeaeb88105ef8..d9311c600bead8f36d468a4e9786f6c2e685c337e7d6cbeb5f04b1c22a910ee1 100644 (file)
--- a/pyac/tests/test_tai.py
+++ b/pyac/tests/test_tai.py
@@ -53,21 +53,21 @@ class TestTAI64(TestCase):
     def test_encode_decode_tai64(self, junk: bytes) -> None:
         dt = datetime(2023, 10, 1, 12, 0, 0)
         encoded = dumps(dt)
-        self.assertEqual(encoded, b"\x18\x40\x00\x00\x00\x65\x19\x5f\x65")
+        self.assertSequenceEqual(encoded, b"\x18\x40\x00\x00\x00\x65\x19\x5f\x65")
         decoded, tail = loads(encoded + junk)
         self.assertEqual(dt, decoded)
-        self.assertEqual(tail, junk)
+        self.assertSequenceEqual(tail, junk)
 
     @given(junk_st)
     def test_encode_decode_tai64n(self, junk: bytes) -> None:
         dt = datetime(2023, 10, 1, 12, 0, 0, 123456)
         encoded = dumps(dt) + junk
-        self.assertEqual(
+        self.assertSequenceEqual(
             encoded, b"\x19\x40\x00\x00\x00\x65\x19\x5f\x65\x07\x5b\xca\x00" + junk
         )
         decoded, tail = loads(encoded)
         self.assertEqual(dt, decoded)
-        self.assertEqual(tail, junk)
+        self.assertSequenceEqual(tail, junk)
 
     @given(junk_st)
     def test_decode_tai64na(self, junk: bytes) -> None:
@@ -80,7 +80,7 @@ class TestTAI64(TestCase):
         )
         decoded, tail = loads(encoded)
         self.assertEqual(decoded, expected)
-        self.assertEqual(tail, junk)
+        self.assertSequenceEqual(tail, junk)
 
     def test_throws_when_not_enough_data_for_tai64(self) -> None:
         with self.assertRaises(NotEnoughData):
@@ -97,14 +97,14 @@ class TestTAI64(TestCase):
     def test_large_number_of_secs(self) -> None:
         decoded, tail = loads(b"\x18\x70\x00\x00\x00\x65\x19\x5f\x65")
         self.assertEqual(decoded, Raw(t=24, v=b"p\x00\x00\x00e\x19_e"))
-        self.assertEqual(tail, b"")
+        self.assertSequenceEqual(tail, b"")
 
     def test_nanoseconds_not_convertible_to_microseconds(self) -> None:
         decoded, tail = loads(
             b"\x19\x40\x00\x00\x00\x65\x19\x5f\x65\x07\x5b\xca\x01"
         )
         self.assertEqual(decoded, Raw(t=25, v=b"@\x00\x00\x00e\x19_e\x07[\xca\x01"))
-        self.assertEqual(tail, b"")
+        self.assertSequenceEqual(tail, b"")
 
     def test_throws_when_first_bit_is_in_use(self) -> None:
         with self.assertRaises(DecodeError) as cm:

diff --git a/pyac/tests/test_uuid.py b/pyac/tests/test_uuid.py
index a5c286d85d676cee0fb0eaa83613855159b01f9305eefbd6f0a3917eb6372177..f0263cfae9fa730bd8fa44671cbfb71cbdf13be51881adc315930a6d3da170e5 100644 (file)
--- a/pyac/tests/test_uuid.py
+++ b/pyac/tests/test_uuid.py
@@ -11,7 +11,7 @@ class TestUUID(TestCase):
         uuid_str: str = "12345678-1234-5678-1234-567812345678"
         uuid_obj: UUID = UUID(uuid_str)
         encoded: bytes = dumps(uuid_obj)
-        self.assertEqual(encoded, b"\x04\x124Vx\x124Vx\x124Vx\x124Vx")
+        self.assertSequenceEqual(encoded, b"\x04\x124Vx\x124Vx\x124Vx\x124Vx")
 
     def test_uuid_decode(self) -> None:
         uuid_str: str = "12345678-1234-5678-1234-567812345678"