From: Sergey Matveev Date: Sun, 1 Dec 2024 10:02:06 +0000 (+0300) Subject: Pure hex (non escaped) encoding is easier to read and more compact X-Git-Url: http://www.git.cypherpunks.su/?a=commitdiff_plain;h=8e1afd139fcaf70cf390a7e44bee1f60f0f43ad7f8a29bc95e9c7588ed722054;p=keks.git Pure hex (non escaped) encoding is easier to read and more compact --- diff --git a/pyac/test-vector.py b/pyac/test-vector.py index 97eeaee..6e17051 100644 --- a/pyac/test-vector.py +++ b/pyac/test-vector.py @@ -16,7 +16,7 @@ data = { -123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789123456789, ], }, - "floats": [pyac.Raw(pyac.TagFloat32, b"\x01\x02\x03\x04")], + "floats": [pyac.Raw(pyac.TagFloat32, bytes.fromhex("01020304"))], "nil": None, "bool": [True, False], "str": { diff --git a/pyac/tests/test_blob.py b/pyac/tests/test_blob.py index 42840cf..65efa45 100644 --- a/pyac/tests/test_blob.py +++ b/pyac/tests/test_blob.py @@ -35,7 +35,12 @@ class TestBlob(TestCase): encoded = dumps(blob) self.assertSequenceEqual( encoded, - b"\x0b\x00\x00\x00\x00\x00\x00\x00\x03\x01test\x01data\x80", + b"".join(( + bytes.fromhex("0B0000000000000003"), + bytes.fromhex("01"), b"test", + bytes.fromhex("01"), b"data", + bytes.fromhex("80"), + )), ) decoded, tail = loads(encoded + junk) self.assertEqual(decoded.l, blob.l) @@ -48,7 +53,12 @@ class TestBlob(TestCase): encoded = dumps(blob) self.assertSequenceEqual( encoded, - b"\x0b\x00\x00\x00\x00\x00\x00\x00\x03\x01test\x01data\x812", + b"".join(( + bytes.fromhex("0B0000000000000003"), + bytes.fromhex("01"), b"test", + bytes.fromhex("01"), b"data", + bytes.fromhex("81"), b"2", + )), ) decoded, tail = loads(encoded + junk) self.assertEqual(decoded.l, blob.l) @@ -61,7 +71,10 @@ class TestBlob(TestCase): encoded = dumps(blob) self.assertSequenceEqual( encoded, - b"\x0b\x00\x00\x00\x00\x00\x00\x00\x03\x80", + b"".join(( + bytes.fromhex("0B0000000000000003"), + bytes.fromhex("80"), + )), ) decoded, tail = loads(encoded + junk) self.assertEqual(decoded.l, 4) @@ -88,25 +101,39 @@ class TestBlob(TestCase): 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" + encoded = b"".join(( + bytes.fromhex("0B0000000000000003"), + bytes.fromhex("01"), b"test", + bytes.fromhex("01"), b"da", + )) with self.assertRaises(NotEnoughData) as err: loads(encoded) self.assertEqual(err.exception.n, 3) def test_throws_when_not_enough_data_for_length(self) -> None: - encoded = b"\x0b\x00\x00\x00\x00" + encoded = bytes.fromhex("0B00000000") with self.assertRaises(NotEnoughData) as err: loads(encoded) self.assertEqual(err.exception.n, 8-4) def test_throws_when_wrong_terminator_length(self) -> None: - encoded = b"\x0b\x00\x00\x00\x00\x00\x00\x00\x03\x01test\x01data\x8Aterminator" + encoded = b"".join(( + bytes.fromhex("0B0000000000000003"), + bytes.fromhex("01"), b"test", + bytes.fromhex("01"), b"data", + bytes.fromhex("8A"), b"terminator", + )) with self.assertRaises(DecodeError) as err: loads(encoded) self.assertEqual(str(err.exception), "wrong terminator len") def test_throws_when_wrong_terminator_tag(self) -> None: - encoded = b"\x0b\x00\x00\x00\x00\x00\x00\x00\x03\x01test\x01data\x04that was a wrong tag" + encoded = b"".join(( + bytes.fromhex("0B0000000000000003"), + bytes.fromhex("01"), b"test", + bytes.fromhex("01"), b"data", + bytes.fromhex("04"), b"that was a wrong tag", + )) with self.assertRaises(DecodeError) as err: loads(encoded) self.assertEqual(str(err.exception), "unexpected tag") diff --git a/pyac/tests/test_int.py b/pyac/tests/test_int.py index 1ee7163..46bfac2 100644 --- a/pyac/tests/test_int.py +++ b/pyac/tests/test_int.py @@ -30,7 +30,7 @@ class TestInt(TestCase): @given(junk_st) def test_0(self, junk: bytes) -> None: encoded: bytes = dumps(0) - self.assertSequenceEqual(encoded, b"\x0c\x80") + self.assertSequenceEqual(encoded, bytes.fromhex("0C80")) decoded, tail = loads(encoded) self.assertEqual(decoded, 0) self.assertSequenceEqual(tail, b"") @@ -38,7 +38,7 @@ class TestInt(TestCase): @given(junk_st) def test_1(self, junk: bytes) -> None: encoded: bytes = dumps(1) - self.assertSequenceEqual(encoded, b"\x0c\x81\x01") + self.assertSequenceEqual(encoded, bytes.fromhex("0C8101")) decoded, tail = loads(encoded + junk) self.assertEqual(decoded, 1) self.assertSequenceEqual(tail, junk) @@ -46,7 +46,7 @@ class TestInt(TestCase): @given(junk_st) def test_123(self, junk: bytes) -> None: encoded: bytes = dumps(123) - self.assertSequenceEqual(encoded, b"\x0c\x81\x7b") + self.assertSequenceEqual(encoded, bytes.fromhex("0C817B")) decoded, tail = loads(encoded + junk) self.assertEqual(decoded, 123) self.assertSequenceEqual(tail, junk) @@ -54,7 +54,10 @@ class TestInt(TestCase): @given(junk_st) def test_1s64(self, junk: bytes) -> None: encoded: bytes = dumps(1 << 64) - self.assertSequenceEqual(encoded, b"\x0c\x89\x01\x00\x00\x00\x00\x00\x00\x00\x00") + self.assertSequenceEqual( + encoded, + bytes.fromhex("0C89010000000000000000"), + ) decoded, tail = loads(encoded + junk) self.assertEqual(decoded, 1 << 64) self.assertSequenceEqual(tail, junk) @@ -62,7 +65,10 @@ class TestInt(TestCase): @given(junk_st) def test_1s130(self, junk: bytes) -> None: encoded: bytes = dumps(1 << 130) - self.assertSequenceEqual(encoded, b"\x0c\x91\x04\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00") + self.assertSequenceEqual( + encoded, + bytes.fromhex("0C910400000000000000000000000000000000"), + ) decoded, tail = loads(encoded + junk) self.assertEqual(decoded, 1 << 130) self.assertSequenceEqual(tail, junk) @@ -70,7 +76,7 @@ class TestInt(TestCase): @given(junk_st) def test_m1(self, junk: bytes) -> None: encoded: bytes = dumps(-1) - self.assertSequenceEqual(encoded, b"\x0d\x80") + self.assertSequenceEqual(encoded, bytes.fromhex("0D80")) decoded, tail = loads(encoded + junk) self.assertEqual(decoded, -1) self.assertSequenceEqual(tail, junk) @@ -78,7 +84,7 @@ class TestInt(TestCase): @given(junk_st) def test_m123(self, junk: bytes) -> None: encoded: bytes = dumps(-123) - self.assertSequenceEqual(encoded, b"\x0d\x81\x7a") + self.assertSequenceEqual(encoded, bytes.fromhex("0D817A")) decoded, tail = loads(encoded + junk) self.assertEqual(decoded, -123) self.assertSequenceEqual(tail, junk) @@ -86,7 +92,7 @@ class TestInt(TestCase): @given(junk_st) def test_m1s64(self, junk: bytes) -> None: encoded: bytes = dumps(-(1 << 64)) - self.assertSequenceEqual(encoded, b"\x0d\x88\xff\xff\xff\xff\xff\xff\xff\xff") + self.assertSequenceEqual(encoded, bytes.fromhex("0D88FFFFFFFFFFFFFFFF")) decoded, tail = loads(encoded + junk) self.assertEqual(decoded, -(1 << 64)) self.assertSequenceEqual(tail, junk) @@ -94,28 +100,31 @@ class TestInt(TestCase): @given(junk_st) def test_m1s130(self, junk: bytes) -> None: encoded: bytes = dumps(-(1 << 130)) - self.assertSequenceEqual(encoded, b"\x0d\x91\x03\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff") + self.assertSequenceEqual( + encoded, + bytes.fromhex("0D9103FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF"), + ) decoded, tail = loads(encoded + junk) self.assertEqual(decoded, -(1 << 130)) self.assertSequenceEqual(tail, junk) def test_decode_not_enough_data(self) -> None: with self.assertRaises(NotEnoughData) as err: - loads(b"\x0c\x83\x01\x02") + loads(bytes.fromhex("0C830102")) self.assertEqual(err.exception.n, 1) with self.assertRaises(NotEnoughData) as err: - loads(b"\x0c\x83\x01") + loads(bytes.fromhex("0C8301")) self.assertEqual(err.exception.n, 2) def test_throws_when_unminimal_int(self) -> None: with self.assertRaises(DecodeError) as err: - encoded: bytes = b"\x0c\x81\x00\x7b" + encoded: bytes = bytes.fromhex("0C81007B") loads(encoded) self.assertEqual(str(err.exception), "non-minimal encoding") def test_throws_when_non_bin_in_int(self) -> None: with self.assertRaises(DecodeError) as err: - encoded: bytes = b"\x0c\x01\x7b" + encoded: bytes = bytes.fromhex("0C017B") loads(encoded) self.assertEqual(str(err.exception), "non-BIN in INT") diff --git a/pyac/tests/test_map.py b/pyac/tests/test_map.py index 5e31c9c..5e895b7 100644 --- a/pyac/tests/test_map.py +++ b/pyac/tests/test_map.py @@ -68,13 +68,27 @@ class TestMap(TestCase): self.assertSequenceEqual(tail, junk) def test_throws_when_decoding_unsorted_value_keys(self): - encoded = b"\x09\xc4key2\x0c\x81\x01\xc4key1\xc6value1\x00" + encoded = b"".join(( + bytes.fromhex("09"), + bytes.fromhex("C4"), b"key2", + bytes.fromhex("0C8101"), + bytes.fromhex("C4"), b"key1", + bytes.fromhex("C6"), b"value1", + bytes.fromhex("00"), + )) with self.assertRaises(DecodeError) as err: loads(encoded) self.assertEqual(str(err.exception), "unsorted keys") def test_throws_when_decoding_unsorted_len_keys(self): - encoded = b"\x09\xc4key2\x0c\x81\x01\xc3key\xc6value1\x00" + encoded = b"".join(( + bytes.fromhex("09"), + bytes.fromhex("C4"), b"key2", + bytes.fromhex("0C8101"), + bytes.fromhex("C3"), b"key", + bytes.fromhex("C6"), b"value1", + bytes.fromhex("00"), + )) with self.assertRaises(DecodeError) as err: loads(encoded) self.assertEqual(str(err.exception), "unsorted keys") @@ -85,13 +99,22 @@ class TestMap(TestCase): self.assertEqual(str(err.exception), "map keys can be only strings") def test_throws_when_decoding_non_string_key(self): - encoded = b"\x09\x0c\x80\xc6value2\x00" + encoded = b"".join(( + bytes.fromhex("09"), + bytes.fromhex("0C80C6"), b"value2", + bytes.fromhex("00"), + )) with self.assertRaises(DecodeError) as err: loads(encoded) self.assertEqual(str(err.exception), "non-string key") def test_throws_when_unexpected_eoc(self): - encoded = b"\x09\xc4key1\x00\x00" + encoded = b"".join(( + bytes.fromhex("09"), + bytes.fromhex("C4"), b"key1", + bytes.fromhex("00"), + bytes.fromhex("00"), + )) with self.assertRaises(DecodeError) as err: decoded, tail = loads(encoded) self.assertEqual(str(err.exception), "unexpected EOC") @@ -102,7 +125,14 @@ class TestMap(TestCase): self.assertEqual(str(err.exception), "map keys can not be empty") def test_throws_when_decoding_empty_str_as_key(self): - encoded = b"\x09\xc0\x0c\x81\x01\xc4key1\xc6value1\x00" + encoded = b"".join(( + bytes.fromhex("09"), + bytes.fromhex("C0"), + bytes.fromhex("0C8101"), + bytes.fromhex("C4"), b"key1", + bytes.fromhex("C6"), b"value1", + bytes.fromhex("00"), + )) with self.assertRaises(DecodeError) as err: decoded, tail = loads(encoded) self.assertEqual(str(err.exception), "empty key") diff --git a/pyac/tests/test_str.py b/pyac/tests/test_str.py index 3b1ed12..c1c6224 100644 --- a/pyac/tests/test_str.py +++ b/pyac/tests/test_str.py @@ -66,10 +66,7 @@ class TestStr(TestCase): def test_hello_world(self, junk: bytes) -> None: s: str = "hello world" encoded: bytes = dumps(s) - self.assertSequenceEqual( - encoded, - b"\xcb\x68\x65\x6c\x6c\x6f\x20\x77\x6f\x72\x6c\x64", - ) + self.assertSequenceEqual(encoded, bytes.fromhex("CB") + b"hello world") decoded, tail = loads(encoded + junk) self.assertSequenceEqual(decoded, s) self.assertSequenceEqual(tail, junk) @@ -80,7 +77,7 @@ class TestStr(TestCase): encoded: bytes = dumps(s) self.assertSequenceEqual( encoded, - b"\xd3\xd0\xbf\xd1\x80\xd0\xb8\xd0\xb2\xd0\xb5\xd1\x82\x20\xd0\xbc\xd0\xb8\xd1\x80", + bytes.fromhex("D3") + "привет мир".encode("utf-8"), ) decoded, tail = loads(encoded + junk) self.assertSequenceEqual(decoded, s) diff --git a/pyac/tests/test_tai.py b/pyac/tests/test_tai.py index cd910b9..5262e69 100644 --- a/pyac/tests/test_tai.py +++ b/pyac/tests/test_tai.py @@ -36,33 +36,33 @@ TagTAI64NA = 0x1A # This is output of: curl http://cr.yp.to/libtai/leapsecs.dat | xxd -c 8 -p DJB_Leapsecs = ( - "4000000004b2580a", - "4000000005a4ec0b", - "4000000007861f8c", - "400000000967530d", - "400000000b48868e", - "400000000d2b0b8f", - "400000000f0c3f10", - "4000000010ed7291", - "4000000012cea612", - "40000000159fca93", - "400000001780fe14", + "4000000004B2580A", + "4000000005A4EC0B", + "4000000007861F8C", + "400000000967530D", + "400000000B48868E", + "400000000D2B0B8F", + "400000000F0C3F10", + "4000000010ED7291", + "4000000012CEA612", + "40000000159FCA93", + "400000001780FE14", "4000000019623195", - "400000001d25ea16", - "4000000021dae517", - "40000000259e9d98", - "40000000277fd119", - "400000002a50f59a", - "400000002c32291b", - "400000002e135c9c", - "4000000030e7241d", - "4000000033b8489e", - "40000000368c101f", - "4000000043b71ba0", - "40000000495c07a1", - "400000004fef9322", - "4000000055932da3", - "40000000586846a4", + "400000001D25EA16", + "4000000021DAE517", + "40000000259E9D98", + "40000000277FD119", + "400000002A50F59A", + "400000002C32291B", + "400000002E135C9C", + "4000000030E7241D", + "4000000033B8489E", + "40000000368C101F", + "4000000043B71BA0", + "40000000495C07A1", + "400000004FEF9322", + "4000000055932DA3", + "40000000586846A4", ) @@ -81,15 +81,13 @@ class TestTAI64(TestCase): self.assertEqual(err.exception.n, 1) 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=0x18, v=b"\x70\x00\x00\x00\x65\x19\x5f\x65"), - ) + decoded, tail = loads(bytes.fromhex("187000000065195F65")) + self.assertEqual(decoded, Raw(t=0x18, v=bytes.fromhex("7000000065195F65"))) self.assertSequenceEqual(tail, b"") def test_throws_when_first_bit_is_in_use(self) -> None: with self.assertRaises(DecodeError) as err: - loads(b"\x18\x80\x00\x00\x00\x65\x19\x5f\x65") + loads(bytes.fromhex("188000000065195F65")) self.assertEqual(str(err.exception), "reserved TAI64 value is in use") @@ -107,19 +105,17 @@ class TestTAI64N(TestCase): self.assertEqual(err.exception.n, 2) 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=0x19, - v=b"\x40\x00\x00\x00\x65\x19\x5f\x65\x07\x5b\xca\x01"), + decoded, tail = loads(bytes.fromhex("194000000065195F65075BCA01")) + self.assertEqual( + decoded, + Raw(t=0x19, v=bytes.fromhex("4000000065195F65075BCA01")), ) self.assertSequenceEqual(tail, b"") def test_throws_when_too_many_nanosecs(self) -> None: with self.assertRaises(DecodeError) as err: loads( - b"\x19\x40\x00\x00\x00\x65\x19\x5f\x65" + + bytes.fromhex("194000000065195F65") + (999999999 + 1).to_bytes(4, "big") ) self.assertEqual(str(err.exception), "too many nanoseconds") @@ -127,26 +123,27 @@ class TestTAI64N(TestCase): def test_zero_nanoseconds(self) -> None: with self.assertRaises(DecodeError) as err: loads( - b"\x19\x40\x00\x00\x00\x00\x00\x00\x00" + - b"\x00\x00\x00\x00" + bytes.fromhex("194000000000000000") + + bytes.fromhex("00000000") ) self.assertEqual(str(err.exception), "non-minimal TAI64N") def test_large_number_of_secs(self) -> None: decoded, tail = loads( - b"\x19\x70\x00\x00\x00\x65\x19\x5f\x65" + - b"\x00\x01\x00\x00" + bytes.fromhex("197000000065195F65") + + bytes.fromhex("00010000") + ) + self.assertEqual( + decoded, + Raw(t=0x19, v=bytes.fromhex("7000000065195F65") + bytes.fromhex("00010000")), ) - self.assertEqual(decoded, Raw( - t=0x19, v=b"\x70\x00\x00\x00\x65\x19\x5f\x65" + b"\x00\x01\x00\x00", - )) self.assertSequenceEqual(tail, b"") def test_throws_when_first_bit_is_in_use(self) -> None: with self.assertRaises(DecodeError) as err: loads( - b"\x19\x80\x00\x00\x00\x65\x19\x5f\x65" + - b"\x00\x01\x00\x00" + bytes.fromhex("198000000065195F65") + + bytes.fromhex("00010000") ) self.assertEqual(str(err.exception), "reserved TAI64 value is in use") @@ -154,14 +151,8 @@ class TestTAI64N(TestCase): class TestTAI64NA(TestCase): @given(junk_st) def test_decode(self, junk: bytes) -> None: - encoded = ( - b"\x1a\x40\x00\x00\x00\x65\x19\x5f\x65\x07\x5b\xca\x00\x07\x5b\xca\x00" + - junk - ) - expected = Raw( - t=0x1a, - v=b"\x40\x00\x00\x00\x65\x19\x5f\x65\x07\x5b\xca\x00\x07\x5b\xca\x00", - ) + encoded = bytes.fromhex("1A4000000065195F65075BCA00075BCA00") + junk + expected = Raw(t=0x1A, v=bytes.fromhex("4000000065195F65075BCA00075BCA00")) decoded, tail = loads(encoded) self.assertEqual(decoded, expected) self.assertSequenceEqual(tail, junk) @@ -173,74 +164,70 @@ class TestTAI64NA(TestCase): def test_throws_when_too_many_attosecs(self) -> None: with self.assertRaises(DecodeError) as err: - loads( - b"\x1a\x40\x00\x00\x00\x65\x19\x5f\x65\x07\x5b\xca\x00\xa7\x5b\xca\x00" - ) + loads(bytes.fromhex("1A4000000065195F65075BCA00A75BCA00")) self.assertEqual(str(err.exception), "too many attoseconds") def test_zero_attoseconds(self) -> None: with self.assertRaises(DecodeError) as err: loads( - b"\x1a\x40\x00\x00\x00\x00\x00\x00\x00" + - b"\x00\x00\x00\x00" + - b"\x00\x00\x00\x00" + bytes.fromhex("1A4000000000000000") + + bytes.fromhex("00000000") + + bytes.fromhex("00000000") ) self.assertEqual(str(err.exception), "non-minimal TAI64NA") def test_zero_nanoseconds_ok_for_tai64na(self) -> None: loads( - b"\x1a\x40\x00\x00\x00\x00\x00\x00\x00" + - b"\x00\x00\x00\x00" + - b"\x00\x00\x00\x01" + bytes.fromhex("1A4000000000000000") + + bytes.fromhex("00000000") + + bytes.fromhex("00000001") ) def test_large_number_of_secs(self) -> None: decoded, tail = loads( - b"\x1a\x70\x00\x00\x00\x65\x19\x5f\x65" + - b"\x00\x01\x00\x00" + - b"\x00\x01\x00\x00" + bytes.fromhex("1A7000000065195F65") + + bytes.fromhex("00010000") + + bytes.fromhex("00010000") ) self.assertEqual(decoded, Raw( - t=0x1a, - v=b"\x70\x00\x00\x00\x65\x19\x5f\x65" + 2 * b"\x00\x01\x00\x00"), - ) + t=0x1A, + v=bytes.fromhex("7000000065195F65") + 2 * bytes.fromhex("00010000"), + )) self.assertSequenceEqual(tail, b"") def test_throws_when_first_bit_is_in_use(self) -> None: with self.assertRaises(DecodeError) as err: loads( - b"\x1a\x80\x00\x00\x00\x65\x19\x5f\x65" + - b"\x00\x01\x00\x00" + - b"\x00\x01\x00\x00" + bytes.fromhex("1A8000000065195F65") + + bytes.fromhex("00010000") + + bytes.fromhex("00010000") ) self.assertEqual(str(err.exception), "reserved TAI64 value is in use") class TestVectors(TestCase): def test_19700101(self) -> None: - decoded, _ = loads(b"\x18\x40\x00\x00\x00\x00\x00\x00\x0a") + decoded, _ = loads(bytes.fromhex("18400000000000000A")) self.assertEqual(decoded, datetime(1970, 1, 1, 0, 0)) def test_19920602(self) -> None: - decoded, _ = loads(b"\x18\x40\x00\x00\x00\x2a\x2b\x2c\x2d") + decoded, _ = loads(bytes.fromhex("18400000002A2B2C2D")) self.assertEqual(decoded, datetime(1992, 6, 2, 8, 6, 43)) def test_19971003(self) -> None: - decoded, _ = loads(b"\x18\x40\x00\x00\x00\x34\x35\x36\x37") + decoded, _ = loads(bytes.fromhex("184000000034353637")) self.assertEqual(decoded, datetime(1997, 10, 3, 18, 14, 48)) def test_20161231(self) -> None: - decoded, _ = loads(b"\x18\x40\x00\x00\x00\x58\x68\x46\xa3") + decoded, _ = loads(bytes.fromhex("1840000000586846A3")) self.assertEqual(decoded, datetime(2016, 12, 31, 23, 59, 59)) def test_20170101(self) -> None: - decoded, _ = loads(b"\x18\x40\x00\x00\x00\x58\x68\x46\xa5") + decoded, _ = loads(bytes.fromhex("1840000000586846A5")) self.assertEqual(decoded, datetime(2017, 1, 1, 0, 0)) def test_20241120(self) -> None: - decoded, _ = loads( - b"\x19\x40\x00\x00\x00\x67\x3d\xd3\xe1\x36\xf1\x1f\xe0", - ) + decoded, _ = loads(bytes.fromhex("1940000000673DD3E136F11FE0")) self.assertEqual(decoded, datetime(2024, 11, 20, 12, 19, 8, 921772)) diff --git a/pyac/tests/test_uuid.py b/pyac/tests/test_uuid.py index 1ee0bfe..1259997 100644 --- a/pyac/tests/test_uuid.py +++ b/pyac/tests/test_uuid.py @@ -33,20 +33,20 @@ class TestUUID(TestCase): encoded: bytes = dumps(uuid_obj) self.assertSequenceEqual( encoded, - b"\x04\x12\x34\x56\x78\x12\x34\x56\x78\x12\x34\x56\x78\x12\x34\x56\x78", + bytes.fromhex("0412345678123456781234567812345678"), ) @given(junk_st) def test_decode(self, junk: bytes) -> None: uuid_str: str = "12345678-1234-5678-1234-567812345678" - encoded: bytes = b"\x04\x12\x34\x56\x78\x12\x34\x56\x78\x12\x34\x56\x78\x12\x34\x56\x78" + encoded: bytes = bytes.fromhex("0412345678123456781234567812345678") decoded: UUID decoded, tail = loads(encoded + junk) self.assertEqual(decoded, UUID(uuid_str)) self.assertSequenceEqual(tail, junk) def test_not_enough_data(self) -> None: - encoded: bytes = b"\x04\x12\x34\x56\x78\x12\x34\x56\x78\x12\x34\x56\x78\x12\x34\x56\x78" + encoded: bytes = bytes.fromhex("0412345678123456781234567812345678") with self.assertRaises(NotEnoughData) as err: loads(encoded[:-4]) self.assertEqual(err.exception.n, 4)