Split TAI-related tests for each separate type

diff --git a/pyac/tests/test_tai.py b/pyac/tests/test_tai.py
index 5105726c93a8ffcc16886e678fd76391e88527e6ebe19259c22fdd34dd1b7379..3a6f9f994c035a8da549f6fcf7d56af09deb3eb75e6d40dde77c121b9010d8d7 100644 (file)
--- a/pyac/tests/test_tai.py
+++ b/pyac/tests/test_tai.py
@@ -52,46 +52,17 @@ DJB_Leapsecs = (
 
 class TestTAI64(TestCase):
     @given(datetimes(), junk_st)
-    def test_symmetric_tai64(self, dt: datetime, junk: bytes) -> None:
+    def test_symmetric(self, dt: datetime, junk: bytes) -> None:
         dt = dt.replace(microsecond=0)
         encoded = dumps(dt)
         decoded, tail = loads(encoded + junk)
         self.assertEqual(dt, decoded)
         self.assertSequenceEqual(tail, junk)
 
-    @given(datetimes(), junk_st)
-    def test_symmetric_tai64n(self, dt: datetime, junk: bytes) -> None:
-        encoded = dumps(dt)
-        decoded, tail = loads(encoded + junk)
-        self.assertEqual(dt, decoded)
-        self.assertSequenceEqual(tail, junk)
-
-    @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" +
-            junk
-        )
-        expected = Raw(
-            t=0x1a,
-            v=b"\x40\x00\x00\x00\x65\x19\x5f\x65\x07\x5b\xca\x00\x07\x5b\xca\x00",
-        )
-        decoded, tail = loads(encoded)
-        self.assertEqual(decoded, expected)
-        self.assertSequenceEqual(tail, junk)
-
-    def test_throws_when_not_enough_data_for_tai64(self) -> None:
+    def test_throws_when_not_enough_data(self) -> None:
         with self.assertRaises(NotEnoughData):
             loads(b"\x18" + b"\x00" * 7)
 
-    def test_throws_when_not_enough_data_for_tai64n(self) -> None:
-        with self.assertRaises(NotEnoughData):
-            loads(b"\x19" + b"\x00" * 11)
-
-    def test_throws_when_not_enough_data_for_tai64na(self) -> None:
-        with self.assertRaises(NotEnoughData):
-            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")
         self.assertEqual(decoded, Raw(
@@ -99,6 +70,24 @@ class TestTAI64(TestCase):
         )
         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")
+        self.assertEqual(str(err.exception), "reserved TAI64 value is in use")
+
+
+class TestTAI64N(TestCase):
+    @given(datetimes(), junk_st)
+    def test_symmetric_tai64n(self, dt: datetime, junk: bytes) -> None:
+        encoded = dumps(dt)
+        decoded, tail = loads(encoded + junk)
+        self.assertEqual(dt, decoded)
+        self.assertSequenceEqual(tail, junk)
+
+    def test_throws_when_not_enough_data(self) -> None:
+        with self.assertRaises(NotEnoughData):
+            loads(b"\x19" + b"\x00" * 11)
+
     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"
@@ -109,11 +98,6 @@ class TestTAI64(TestCase):
         )
         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")
-        self.assertEqual(str(err.exception), "reserved TAI64 value is in use")
-
     def test_throws_when_too_many_nanosecs(self) -> None:
         with self.assertRaises(DecodeError) as err:
             loads(
@@ -122,13 +106,6 @@ class TestTAI64(TestCase):
             )
         self.assertEqual(str(err.exception), "too many nanoseconds")
 
-    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"
-            )
-        self.assertEqual(str(err.exception), "too many attoseconds")
-
     def test_zero_nanoseconds(self) -> None:
         with self.assertRaises(DecodeError) as err:
             loads(
@@ -137,6 +114,51 @@ class TestTAI64(TestCase):
             )
         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"
+        )
+        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"
+            )
+        self.assertEqual(str(err.exception), "reserved TAI64 value is in use")
+
+
+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",
+        )
+        decoded, tail = loads(encoded)
+        self.assertEqual(decoded, expected)
+        self.assertSequenceEqual(tail, junk)
+
+    def test_throws_when_not_enough_data(self) -> None:
+        with self.assertRaises(NotEnoughData):
+            loads(b"\x1a" + b"\x00" * 15)
+
+    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"
+            )
+        self.assertEqual(str(err.exception), "too many attoseconds")
+
     def test_zero_attoseconds(self) -> None:
         with self.assertRaises(DecodeError) as err:
             loads(
@@ -153,6 +175,27 @@ class TestTAI64(TestCase):
             b"\x00\x00\x00\x01"
         )
 
+    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"
+        )
+        self.assertEqual(decoded, Raw(
+            t=0x1a,
+            v=b"\x70\x00\x00\x00\x65\x19\x5f\x65" + 2 * 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"\x1a\x80\x00\x00\x00\x65\x19\x5f\x65" +
+                b"\x00\x01\x00\x00" +
+                b"\x00\x01\x00\x00"
+            )
+        self.assertEqual(str(err.exception), "reserved TAI64 value is in use")
+
 
 class TestLeapsecs(TestCase):
     def test_match_DJB(self) -> None: