Let's use shorter variable name

I have nothing against "remaining", except for its length.
And "tail" term is used in pyac.py already.

diff --git a/pyac/tests/test_blob.py b/pyac/tests/test_blob.py
index 1289ca8d1f3d345447cd6062fcb875a8962dfdd43800a39e64d3f819c6c1dabc..08cd5b64230d0c3aa0da036214fa85437f899f9138e503221e3af0926b0bff9b 100644 (file)
--- a/pyac/tests/test_blob.py
+++ b/pyac/tests/test_blob.py
@@ -21,10 +21,10 @@ class TestBlob(TestCase):
     @given(junk_st)
     def test_blob_decode(self, junk: bytes) -> None:
         encoded = b"\x0B\x00\x00\x00\x00\x00\x00\x00\x03\x01test\x01data\x80" + junk
-        decoded, remaining = loads(encoded)
+        decoded, tail = loads(encoded)
         self.assertEqual(decoded.l, 4)
         self.assertEqual(decoded.v, b"testdata")
-        self.assertEqual(remaining, junk)
+        self.assertEqual(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 048b198e58598023e14549e1f8d6adff0bea8068c467eae37fd7e95c31cf5bf9..f084eb81114df9a5dd993cf33977fd53860986ab95f3f6b41ff4de17c1687c4b 100644 (file)
--- a/pyac/tests/test_bool.py
+++ b/pyac/tests/test_bool.py
@@ -19,13 +19,13 @@ class TestBool(TestCase):
     @given(junk_st)
     def test_bool_decode_true(self, junk):
         encoded = b"\x03" + junk
-        decoded, remaining = loads(encoded)
+        decoded, tail = loads(encoded)
         self.assertIs(decoded, True)
-        self.assertEqual(remaining, junk)
+        self.assertEqual(tail, junk)
 
     @given(junk_st)
     def test_bool_decode_false(self, junk):
         encoded = b"\x02" + junk
-        decoded, remaining = loads(encoded)
+        decoded, tail = loads(encoded)
         self.assertIs(decoded, False)
-        self.assertEqual(remaining, junk)
+        self.assertEqual(tail, junk)

diff --git a/pyac/tests/test_float.py b/pyac/tests/test_float.py
index 95207d85671065c6c4a485ef6a0c1c5564d2488436c9facd41f6f1032bf47275..61699d68693b55f74fa026d42c6a5d91e7acc08df7a3c0acc4e42976ee5ba6c2 100644 (file)
--- a/pyac/tests/test_float.py
+++ b/pyac/tests/test_float.py
@@ -29,9 +29,9 @@ class TestFloat(TestCase):
             Raw(0x14, b"\x11" * 32),
         ]
         for _float, expected in zip(floats, expecteds):
-            decoded, remaining = loads(_float)
+            decoded, tail = loads(_float)
             self.assertEqual(decoded, expected)
-            self.assertEqual(remaining, b"")
+            self.assertEqual(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 cb92ad5946cca70072035cd54b3d13243d1fdc1032838f2a56ed008a9f20987c..5c4b819eb64b2548f67cfa9cd915a56b6d801974b0b3775f9b63b1b8f897404a 100644 (file)
--- a/pyac/tests/test_int.py
+++ b/pyac/tests/test_int.py
@@ -17,9 +17,9 @@ class TestInt(TestCase):
         ]
         for integer, encoded in zip(ints, expected):
             self.assertEqual(dumps(integer), encoded)
-            decoded, remaining = loads(encoded)
+            decoded, tail = loads(encoded)
             self.assertEqual(decoded, integer)
-            self.assertEqual(remaining, b"")
+            self.assertEqual(tail, b"")
 
     def test_int_negative(self) -> None:
         ints: list[int] = [-1, -123, -(1 << 64), -(1 << 130)]
@@ -31,16 +31,16 @@ class TestInt(TestCase):
         ]
         for integer, encoded in zip(ints, expected):
             self.assertEqual(dumps(integer), encoded)
-            decoded, remaining = loads(encoded)
+            decoded, tail = loads(encoded)
             self.assertEqual(decoded, integer)
-            self.assertEqual(remaining, b"")
+            self.assertEqual(tail, b"")
 
     def test_int_zero(self) -> None:
         encoded: bytes = dumps(0)
         self.assertEqual(encoded, b"\x0C\x80")
-        decoded, remaining = loads(encoded)
+        decoded, tail = loads(encoded)
         self.assertEqual(decoded, 0)
-        self.assertEqual(remaining, b"")
+        self.assertEqual(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 3367d2c898955140af5f2458d0c3302cb61a767b98ad770a08bf7b9282607371..317f978d004d7cf821f7538127f50db31872d056beb5683660399fac1c5ec924 100644 (file)
--- a/pyac/tests/test_list.py
+++ b/pyac/tests/test_list.py
@@ -25,16 +25,16 @@ class TestList(TestCase):
 
     def test_list_decode_empty(self) -> None:
         encoded = b"\x08\x00"
-        decoded, remaining = loads(encoded)
+        decoded, tail = loads(encoded)
         self.assertEqual(decoded, [])
-        self.assertEqual(remaining, b"")
+        self.assertEqual(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, remaining = loads(encoded)
+        decoded, tail = loads(encoded)
         self.assertEqual(decoded, test_list)
-        self.assertEqual(remaining, junk)
+        self.assertEqual(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 0e9215d282cea02dcc28ca0e880b53d4c374bc71de1dd45c05bc5ea7f3ba4985..4b17f692a4bfc213e590655b35a8cbfdb43943670c81824df8781bb3ae6c497e 100644 (file)
--- a/pyac/tests/test_map.py
+++ b/pyac/tests/test_map.py
@@ -41,9 +41,9 @@ class TestMap(TestCase):
             b"\x00" +
             junk
         )
-        decoded, remaining = loads(encoded)
+        decoded, tail = loads(encoded)
         self.assertEqual(decoded, test_map)
-        self.assertEqual(remaining, junk)
+        self.assertEqual(tail, junk)
 
     @given(junk_st)
     def test_map_empty(self, junk):
@@ -51,17 +51,17 @@ class TestMap(TestCase):
         encoded = dumps(test_map) + junk
         expected = b"\x09\x00" + junk
         self.assertEqual(encoded, expected)
-        decoded, remaining = loads(encoded)
+        decoded, tail = loads(encoded)
         self.assertEqual(decoded, test_map)
-        self.assertEqual(remaining, junk)
+        self.assertEqual(tail, junk)
 
     @given(lists(mapkey_st, max_size=4), junk_st)
     def test_decode_to_set(self, keys, junk):
         test_map = {key: None for key in keys}
         encoded = dumps(test_map) + junk
-        decoded, remaining = loads(encoded, sets=True)
+        decoded, tail = loads(encoded, sets=True)
         self.assertEqual(decoded, set(keys))
-        self.assertEqual(remaining, junk)
+        self.assertEqual(tail, junk)
 
     def test_map_throws_when_decoding_unsorted_keys(self):
         encoded = b"\x09\xc4key2\x0c\x81\x01\xc4key1\xc6value1\x00"
@@ -83,7 +83,7 @@ class TestMap(TestCase):
     def test_map_throws_when_unexpected_eoc(self):
         encoded = b"\x09\xc4key1\x00\x00"
         with self.assertRaises(DecodeError) as cm:
-            decoded, remaining = loads(encoded)
+            decoded, tail = loads(encoded)
         self.assertEqual(str(cm.exception), "unexpected EOC")
 
     def test_map_throws_when_encoding_empty_str_as_key(self):
@@ -94,5 +94,5 @@ class TestMap(TestCase):
     def test_map_throws_when_decoding_empty_str_as_key(self):
         encoded = b"\x09\xc0\x0c\x81\x01\xc4key1\xc6value1\x00"
         with self.assertRaises(DecodeError) as cm:
-            decoded, remaining = loads(encoded)
+            decoded, tail = loads(encoded)
         self.assertEqual(str(cm.exception), "empty key")

diff --git a/pyac/tests/test_str.py b/pyac/tests/test_str.py
index db682bf25efcc5f2ef7e67cfbe283557b89e919563a2c88201f9539d17988cf6..9a92f9f63a1fa96a0aec2167d70463505e54fce15ab5942b24b3e4037080aba2 100644 (file)
--- a/pyac/tests/test_str.py
+++ b/pyac/tests/test_str.py
@@ -38,25 +38,25 @@ class TestString(TestCase):
         long_strings = ["a" * 62, "a" * 318, "a" * 65853]
         for long_string in long_strings:
             encoded = dumps(long_string)
-            decoded, remaining = loads(encoded)
+            decoded, tail = loads(encoded)
             self.assertEqual(decoded, long_string)
-            self.assertEqual(remaining, b"")
+            self.assertEqual(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")
-        decoded, remaining = loads(encoded)
+        decoded, tail = loads(encoded)
         self.assertEqual(decoded, b"\x00\x01\x02")
-        self.assertEqual(remaining, b"")
+        self.assertEqual(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, remaining = loads(encoded)
+            decoded, tail = loads(encoded)
             self.assertEqual(decoded, long_bs)
-            self.assertEqual(remaining, b"")
+            self.assertEqual(tail, b"")
 
     def test_throws_when_not_enough_data(self) -> None:
         encoded = b"\x85he"
@@ -73,19 +73,19 @@ class TestString(TestCase):
 
     def test_throws_when_null_byte_in_utf(self) -> None:
         with self.assertRaises(DecodeError) as cm:
-            result, remaining = loads(b"\xc5he\x00\x01\x02")
+            result, tail = loads(b"\xc5he\x00\x01\x02")
         self.assertEqual(str(cm.exception), "null byte in UTF-8")
 
     @given(invalid_utf8_2byte_s)
     def test_throws_when_invalid_utf_2bytes(self, invalid_utf: bytes) -> None:
         with self.assertRaises(DecodeError) as cm:
             encoded = dumps("hello")[:-1] + invalid_utf
-            result, remaining = loads(encoded)
+            result, tail = loads(encoded)
         self.assertEqual(str(cm.exception), "invalid UTF-8")
 
     @given(invalid_utf8_3byte_s)
     def test_throws_when_invalid_utf_3bytes(self, invalid_utf: bytes) -> None:
         with self.assertRaises(DecodeError) as cm:
             encoded = dumps("hello")[:-2] + invalid_utf
-            result, remaining = loads(encoded)
+            result, tail = loads(encoded)
         self.assertEqual(str(cm.exception), "invalid UTF-8")

diff --git a/pyac/tests/test_symmetric.py b/pyac/tests/test_symmetric.py
index fc91b349a3234c7b02e1edf46e348eeb91a87683065ef4b07bfa03d4142702dc..e11b6425747ea975de499ef935561e488ae188ff08970aa4c79e883d8c598a41 100644 (file)
--- a/pyac/tests/test_symmetric.py
+++ b/pyac/tests/test_symmetric.py
@@ -25,7 +25,7 @@ class TestSymmetric(TestCase):
     def test_symmetric(self, obj: Any, junk: bytes) -> None:
         encoded: bytes = dumps(obj) + junk
         decoded: Any
-        remaining: bytes
-        decoded, remaining = loads(encoded)
-        self.assertSequenceEqual(remaining, junk)
+        tail: bytes
+        decoded, tail = loads(encoded)
+        self.assertSequenceEqual(tail, junk)
         self.assertEqual(decoded, obj)

diff --git a/pyac/tests/test_tai.py b/pyac/tests/test_tai.py
index 1bcebf6b8995353ef0e054fed15aa0df4296a97292be71d9686191614d19160d..3c139ae23254d46790b58ae7fb9a4cb765e7531790492ee58d4aeaeb88105ef8 100644 (file)
--- a/pyac/tests/test_tai.py
+++ b/pyac/tests/test_tai.py
@@ -54,9 +54,9 @@ class TestTAI64(TestCase):
         dt = datetime(2023, 10, 1, 12, 0, 0)
         encoded = dumps(dt)
         self.assertEqual(encoded, b"\x18\x40\x00\x00\x00\x65\x19\x5f\x65")
-        decoded, remaining = loads(encoded + junk)
+        decoded, tail = loads(encoded + junk)
         self.assertEqual(dt, decoded)
-        self.assertEqual(remaining, junk)
+        self.assertEqual(tail, junk)
 
     @given(junk_st)
     def test_encode_decode_tai64n(self, junk: bytes) -> None:
@@ -65,9 +65,9 @@ class TestTAI64(TestCase):
         self.assertEqual(
             encoded, b"\x19\x40\x00\x00\x00\x65\x19\x5f\x65\x07\x5b\xca\x00" + junk
         )
-        decoded, remaining = loads(encoded)
+        decoded, tail = loads(encoded)
         self.assertEqual(dt, decoded)
-        self.assertEqual(remaining, junk)
+        self.assertEqual(tail, junk)
 
     @given(junk_st)
     def test_decode_tai64na(self, junk: bytes) -> None:
@@ -78,9 +78,9 @@ class TestTAI64(TestCase):
         expected = Raw(
             26, b"\x40\x00\x00\x00\x65\x19\x5f\x65\x07\x5b\xca\x00\x07\x5b\xca\x00"
         )
-        decoded, remaining = loads(encoded)
+        decoded, tail = loads(encoded)
         self.assertEqual(decoded, expected)
-        self.assertEqual(remaining, junk)
+        self.assertEqual(tail, junk)
 
     def test_throws_when_not_enough_data_for_tai64(self) -> None:
         with self.assertRaises(NotEnoughData):
@@ -95,16 +95,16 @@ class TestTAI64(TestCase):
             loads(b"\x1A" + b"\x00" * 15)
 
     def test_large_number_of_secs(self) -> None:
-        decoded, remaining = loads(b"\x18\x70\x00\x00\x00\x65\x19\x5f\x65")
+        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(remaining, b"")
+        self.assertEqual(tail, b"")
 
     def test_nanoseconds_not_convertible_to_microseconds(self) -> None:
-        decoded, remaining = loads(
+        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(remaining, b"")
+        self.assertEqual(tail, b"")
 
     def test_throws_when_first_bit_is_in_use(self) -> None:
         with self.assertRaises(DecodeError) as cm:
@@ -138,7 +138,7 @@ class TestTAI64(TestCase):
 
     def test_decode_leapsecond(self) -> None:
         for leapsec in DJB_Leapsecs:
-            decoded, remaining = loads(v=b"\x18" + bytes.fromhex(leapsec), leapsecUTCAllow=True)
+            decoded, tail = loads(v=b"\x18" + bytes.fromhex(leapsec), leapsecUTCAllow=True)
             self.assertIsInstance(decoded, datetime)
-            decoded, remaining = loads(v=b"\x18" + bytes.fromhex(leapsec), leapsecUTCAllow=False)
+            decoded, tail = loads(v=b"\x18" + bytes.fromhex(leapsec), leapsecUTCAllow=False)
             self.assertIsInstance(decoded, Raw)