Unify case in hexadecimal strings

diff --git a/pyac/tests/test_blob.py b/pyac/tests/test_blob.py
index 95c9c1ebf270a1171078d7e2634066442008c385089f6a9a4fbbaeac3530e368..e50c91af9ef6a1d107f4e327895a4f382f8128b7147e571c9ddd76831b5a2b00 100644 (file)
--- a/pyac/tests/test_blob.py
+++ b/pyac/tests/test_blob.py
@@ -60,7 +60,7 @@ class TestBlob(TestCase):
     def test_symmetric_multiple(self, chunkLen: int, chunks: int, junk: bytes) -> None:
         chunks = [urandom(chunkLen) for _ in range(chunks)]
         encoded = b"".join((
-            b"\x0B",
+            b"\x0b",
             (chunkLen-1).to_bytes(8, "big"),
             b"".join((b"\x01" + chunk) for chunk in chunks),
             b"\x80",
@@ -72,25 +72,25 @@ 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"\x0b\x00\x00\x00\x00\x00\x00\x00\x03\x01test\x01da"
         with self.assertRaises(NotEnoughData) as err:
             loads(encoded)
         self.assertEqual(err.exception.n, 4)
 
     def test_throws_when_not_enough_data_for_length(self) -> None:
-        encoded = b"\x0B\x00\x00\x00\x00"
+        encoded = b"\x0b\x00\x00\x00\x00"
         with self.assertRaises(NotEnoughData) as err:
             loads(encoded)
         self.assertEqual(err.exception.n, 9)
 
     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"\x0b\x00\x00\x00\x00\x00\x00\x00\x03\x01test\x01data\x8Aterminator"
         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"\x0b\x00\x00\x00\x00\x00\x00\x00\x03\x01test\x01data\x04that 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 6de6dbd5914c1ddc21fc2cf9fc42b0029e33de0546d3a4f47b86dd7ccc60c9a9..1a6396d247fcf97449d9ce5bc57c59cacdf9934939d965065308e30d82851c7d 100644 (file)
--- a/pyac/tests/test_int.py
+++ b/pyac/tests/test_int.py
@@ -10,8 +10,8 @@ class TestInt(TestCase):
     def test_positive(self) -> None:
         ints: list[int] = [1, 123, 1 << 64, 1 << 130]
         expected: list[bytes] = [
-            b"\x0C\x81\x01",
-            b"\x0C\x81\x7B",
+            b"\x0c\x81\x01",
+            b"\x0c\x81\x7b",
             b"\x0c\x89\x01\x00\x00\x00\x00\x00\x00\x00\x00",
             b"\x0c\x91\x04\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00",
         ]
@@ -24,10 +24,10 @@ class TestInt(TestCase):
     def test_negative(self) -> None:
         ints: list[int] = [-1, -123, -(1 << 64), -(1 << 130)]
         expected: list[bytes] = [
-            b"\x0D\x80",
-            b"\x0D\x81\x7a",
-            b"\x0D\x88\xff\xff\xff\xff\xff\xff\xff\xff",
-            b"\x0D\x91\x03\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff",
+            b"\x0d\x80",
+            b"\x0d\x81\x7a",
+            b"\x0d\x88\xff\xff\xff\xff\xff\xff\xff\xff",
+            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.assertSequenceEqual(dumps(integer), encoded)
@@ -37,25 +37,25 @@ class TestInt(TestCase):
 
     def test_zero(self) -> None:
         encoded: bytes = dumps(0)
-        self.assertSequenceEqual(encoded, b"\x0C\x80")
+        self.assertSequenceEqual(encoded, b"\x0c\x80")
         decoded, tail = loads(encoded)
         self.assertEqual(decoded, 0)
         self.assertSequenceEqual(tail, b"")
 
     def test_decode_not_enough_data(self) -> None:
-        encoded: bytes = b"\x0C\x81"
+        encoded: bytes = b"\x0c\x81"
         with self.assertRaises(NotEnoughData) as err:
             loads(encoded)
         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 = b"\x0c\x81\x00\x7b"
             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 = b"\x0c\x01\x7b"
             loads(encoded)
         self.assertEqual(str(err.exception), "non-BIN in INT")

diff --git a/pyac/tests/test_tai.py b/pyac/tests/test_tai.py
index 39972f90346538b218c4302c44e273e582e62ecb5ab9979ee370c8e0f1dc99ac..fa261a5e6d1308b950d6477805f7237e53134416ea5af25af1c372ad4d53b1b8 100644 (file)
--- a/pyac/tests/test_tai.py
+++ b/pyac/tests/test_tai.py
@@ -72,7 +72,7 @@ class TestTAI64(TestCase):
     @given(junk_st)
     def test_decode_tai64na(self, junk: bytes) -> None:
         encoded = (
-            b"\x1A\x40\x00\x00\x00\x65\x19\x5f\x65\x07\x5b\xca\x00\x07\x5b\xca\x00" +
+            b"\x1a\x40\x00\x00\x00\x65\x19\x5f\x65\x07\x5b\xca\x00\x07\x5b\xca\x00" +
             junk
         )
         expected = Raw(
@@ -92,7 +92,7 @@ class TestTAI64(TestCase):
 
     def test_throws_when_not_enough_data_for_tai64na(self) -> None:
         with self.assertRaises(NotEnoughData):
-            loads(b"\x1A" + b"\x00" * 15)
+            loads(b"\x1a" + b"\x00" * 15)
 
     def test_large_number_of_secs(self) -> None:
         decoded, tail = loads(b"\x18\x70\x00\x00\x00\x65\x19\x5f\x65")
@@ -119,7 +119,7 @@ class TestTAI64(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"
+                b"\x1a\x40\x00\x00\x00\x65\x19\x5f\x65\x07\x5b\xca\x00\xa7\x5b\xca\x00"
             )
         self.assertEqual(str(err.exception), "too many attoseconds")