From: Sergey Matveev Date: Sat, 30 Nov 2024 16:19:16 +0000 (+0300) Subject: Let's use shorter variable name X-Git-Url: http://www.git.cypherpunks.su/?a=commitdiff_plain;h=6893f853290df0e019b1d4f4a6434d102c3fa94b4fba28380cb85c767af48927;p=keks.git 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 1289ca8..08cd5b6 100644 --- 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 048b198..f084eb8 100644 --- 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 95207d8..61699d6 100644 --- 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 cb92ad5..5c4b819 100644 --- 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 3367d2c..317f978 100644 --- 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 0e9215d..4b17f69 100644 --- 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 db682bf..9a92f9f 100644 --- 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 fc91b34..e11b642 100644 --- 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 1bcebf6..3c139ae 100644 --- 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)