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 97eeaee610a7165e3020aae704f22931aba1fa31508050dc455e995716ad1b25..6e170515bc7f45737293ab56fa78424f1dd8f7e3da7cefb0f78b5f3dfffc3911 100644 (file)
--- 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 42840cf0f3780feba35b0622bcff51986011c5e0328b6b967d223820aa17dbb0..65efa451fcb70a740c05c4221d5bda89011266daef6446e0a6dc2152fda787de 100644 (file)
--- 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 1ee71639fc5526bf0db86191081d37eb5fd5a4d314abff90d4d6501c95d13442..46bfac27ec859dbe29cf7b41401397b6eeed182becdb1d51a8735f1bad211f0e 100644 (file)
--- 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 5e31c9cb3919a85e8cb4e776a206460dd9a1ee42049fb07ce2d00b2a8b61098f..5e895b7327062b94e1ab8dfd2ce024a4ee068d14c6b7a072dde627045cd6eb73 100644 (file)
--- 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 3b1ed127ced477ce00f7f993acc28c92580526d599cd994ed242b7e9d4a4f601..c1c6224cb2e76a0540d2de45913844fe4d5b28894454dbef628e55d67fa9635c 100644 (file)
--- 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 cd910b9848c67c22089fb708780f1726feaa9fa91a6439df06c2f43b6c8b5e7f..5262e695fc348324ac1c9ab9423c3c9add83ec6c297d3a3d81b430b163b4e5e9 100644 (file)
--- 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 1ee0bfe9a87a3bcab342d8320372466adeea5a7a93db57da8c28d0cb27be0f1a..12599976af91d201725c83de95cff901b896d594369aabeb2c04c2b3738b900f 100644 (file)
--- 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)