Split floats-related combined tests

Simpler test cases, covering the narrow part of data, as a rule more
convenient to use, because if you have a typo in exactly 128-bit related
floats related code, then *_128 test will show that. Combined tests like
were before will require you using debugger.

diff --git a/pyac/tests/test_float.py b/pyac/tests/test_float.py
index be0405252c59b07125425420941e7a16b6ab38a7458f50f81c62f70db5226b08..96f440ce2f3cce840751d4d34d447b27989dc547347dc13a41fbc51634847ee2 100644 (file)
--- a/pyac/tests/test_float.py
+++ b/pyac/tests/test_float.py
@@ -1,11 +1,14 @@
-from typing import List
 from unittest import TestCase
 
+from hypothesis import given
+
 from pyac import dumps
 from pyac import loads
 from pyac import NotEnoughData
 from pyac import Raw
 
+from tests.strategies import junk_st
+
 
 class TestFloat(TestCase):
     def test_throws_when_dumps_float(self) -> None:
@@ -13,34 +16,57 @@ class TestFloat(TestCase):
             dumps(1.5)
         self.assertEqual(str(err.exception), "no FLOAT* support")
 
-    def test_float_loads(self) -> None:
-        floats: List[bytes] = [
-            b"\x10" + b"\x11" * 2,
-            b"\x11" + b"\x11" * 4,
-            b"\x12" + b"\x11" * 8,
-            b"\x13" + b"\x11" * 16,
-            b"\x14" + b"\x11" * 32,
-        ]
-        expecteds: List[Raw] = [
-            Raw(0x10, b"\x11" * 2),
-            Raw(0x11, b"\x11" * 4),
-            Raw(0x12, b"\x11" * 8),
-            Raw(0x13, b"\x11" * 16),
-            Raw(0x14, b"\x11" * 32),
-        ]
-        for _float, expected in zip(floats, expecteds):
-            decoded, tail = loads(_float)
-            self.assertSequenceEqual(decoded, expected)
-            self.assertSequenceEqual(tail, b"")
-
-    def test_float_not_enough_data(self) -> None:
-        floats: List[bytes] = [
-            b"\x10" + b"\x11" * 1,
-            b"\x11" + b"\x11" * 3,
-            b"\x12" + b"\x11" * 7,
-            b"\x13" + b"\x11" * 15,
-            b"\x14" + b"\x11" * 31,
-        ]
-        for fl in floats:
-            with self.assertRaises(NotEnoughData):
-                loads(fl)
+    @given(junk_st)
+    def test_loads_16(self, junk: bytes) -> None:
+        decoded, tail = loads((b"\x10" + b"\x11" * 2) + junk)
+        self.assertEqual(decoded, Raw(0x10, b"\x11" * 2))
+        self.assertSequenceEqual(tail, junk)
+
+    @given(junk_st)
+    def test_loads_32(self, junk: bytes) -> None:
+        decoded, tail = loads((b"\x11" + b"\x11" * 4) + junk)
+        self.assertEqual(decoded, Raw(0x11, b"\x11" * 4))
+        self.assertSequenceEqual(tail, junk)
+
+    @given(junk_st)
+    def test_loads_64(self, junk: bytes) -> None:
+        decoded, tail = loads((b"\x12" + b"\x11" * 8) + junk)
+        self.assertEqual(decoded, Raw(0x12, b"\x11" * 8))
+        self.assertSequenceEqual(tail, junk)
+
+    @given(junk_st)
+    def test_loads_128(self, junk: bytes) -> None:
+        decoded, tail = loads((b"\x13" + b"\x11" * 16) + junk)
+        self.assertEqual(decoded, Raw(0x13, b"\x11" * 16))
+        self.assertSequenceEqual(tail, junk)
+
+    @given(junk_st)
+    def test_loads_256(self, junk: bytes) -> None:
+        decoded, tail = loads((b"\x14" + b"\x11" * 32) + junk)
+        self.assertEqual(decoded, Raw(0x14, b"\x11" * 32))
+        self.assertSequenceEqual(tail, junk)
+
+    def test_not_enough_data_16(self) -> None:
+        with self.assertRaises(NotEnoughData) as err:
+            loads(b"\x10" + b"\x11" * (2-1))
+        self.assertEqual(err.exception.n, 1+2)
+
+    def test_not_enough_data_32(self) -> None:
+        with self.assertRaises(NotEnoughData) as err:
+            loads(b"\x11" + b"\x11" * (4-1))
+        self.assertEqual(err.exception.n, 1+4)
+
+    def test_not_enough_data_64(self) -> None:
+        with self.assertRaises(NotEnoughData) as err:
+            loads(b"\x12" + b"\x11" * (8-1))
+        self.assertEqual(err.exception.n, 1+8)
+
+    def test_not_enough_data_128(self) -> None:
+        with self.assertRaises(NotEnoughData) as err:
+            loads(b"\x13" + b"\x11" * (16-1))
+        self.assertEqual(err.exception.n, 1+16)
+
+    def test_not_enough_data_256(self) -> None:
+        with self.assertRaises(NotEnoughData) as err:
+            loads(b"\x14" + b"\x11" * (32-1))
+        self.assertEqual(err.exception.n, 1+32)