From 2485717dbcde3ffcb7ea1dc0bef6415877f4a4d89e20a75f2184267ea6f16cd2 Mon Sep 17 00:00:00 2001 From: Sergey Matveev Date: Sat, 30 Nov 2024 22:23:35 +0300 Subject: [PATCH] Split TAI-related tests for each separate type --- pyac/tests/test_tai.py | 129 +++++++++++++++++++++++++++-------------- 1 file changed, 86 insertions(+), 43 deletions(-) diff --git a/pyac/tests/test_tai.py b/pyac/tests/test_tai.py index 5105726..3a6f9f9 100644 --- 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: -- 2.50.0