From 6751f044eba2bb5ac106f686b8e788d72788a71757e2bec8cae4252a0878d1f2 Mon Sep 17 00:00:00 2001
From: Sergey Matveev <stargrave@stargrave.org>
Date: Sat, 30 Nov 2024 20:49:23 +0300
Subject: [PATCH] Split int-related combined tests

---
 pyac/tests/test_int.py | 98 +++++++++++++++++++++++++++++-------------
 1 file changed, 69 insertions(+), 29 deletions(-)

diff --git a/pyac/tests/test_int.py b/pyac/tests/test_int.py
index 1a6396d..93f047d 100644
--- a/pyac/tests/test_int.py
+++ b/pyac/tests/test_int.py
@@ -1,47 +1,87 @@
 from unittest import TestCase
 
+from hypothesis import given
+
 from pyac import DecodeError
 from pyac import dumps
 from pyac import loads
 from pyac import NotEnoughData
+from tests.strategies import junk_st
 
 
 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\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",
-        ]
-        for integer, encoded in zip(ints, expected):
-            self.assertSequenceEqual(dumps(integer), encoded)
-            decoded, tail = loads(encoded)
-            self.assertEqual(decoded, integer)
-            self.assertSequenceEqual(tail, b"")
-
-    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",
-        ]
-        for integer, encoded in zip(ints, expected):
-            self.assertSequenceEqual(dumps(integer), encoded)
-            decoded, tail = loads(encoded)
-            self.assertEqual(decoded, integer)
-            self.assertSequenceEqual(tail, b"")
-
-    def test_zero(self) -> None:
+    @given(junk_st)
+    def test_0(self, junk: bytes) -> None:
         encoded: bytes = dumps(0)
         self.assertSequenceEqual(encoded, b"\x0c\x80")
         decoded, tail = loads(encoded)
         self.assertEqual(decoded, 0)
         self.assertSequenceEqual(tail, b"")
 
+    @given(junk_st)
+    def test_1(self, junk: bytes) -> None:
+        encoded: bytes = dumps(1)
+        self.assertSequenceEqual(encoded, b"\x0c\x81\x01")
+        decoded, tail = loads(encoded + junk)
+        self.assertEqual(decoded, 1)
+        self.assertSequenceEqual(tail, junk)
+
+    @given(junk_st)
+    def test_123(self, junk: bytes) -> None:
+        encoded: bytes = dumps(123)
+        self.assertSequenceEqual(encoded, b"\x0c\x81\x7b")
+        decoded, tail = loads(encoded + junk)
+        self.assertEqual(decoded, 123)
+        self.assertSequenceEqual(tail, junk)
+
+    @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")
+        decoded, tail = loads(encoded + junk)
+        self.assertEqual(decoded, 1 << 64)
+        self.assertSequenceEqual(tail, junk)
+
+    @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")
+        decoded, tail = loads(encoded + junk)
+        self.assertEqual(decoded, 1 << 130)
+        self.assertSequenceEqual(tail, junk)
+
+    @given(junk_st)
+    def test_m1(self, junk: bytes) -> None:
+        encoded: bytes = dumps(-1)
+        self.assertSequenceEqual(encoded, b"\x0d\x80")
+        decoded, tail = loads(encoded + junk)
+        self.assertEqual(decoded, -1)
+        self.assertSequenceEqual(tail, junk)
+
+    @given(junk_st)
+    def test_m123(self, junk: bytes) -> None:
+        encoded: bytes = dumps(-123)
+        self.assertSequenceEqual(encoded, b"\x0d\x81\x7a")
+        decoded, tail = loads(encoded + junk)
+        self.assertEqual(decoded, -123)
+        self.assertSequenceEqual(tail, junk)
+
+    @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")
+        decoded, tail = loads(encoded + junk)
+        self.assertEqual(decoded, -(1 << 64))
+        self.assertSequenceEqual(tail, junk)
+
+    @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")
+        decoded, tail = loads(encoded + junk)
+        self.assertEqual(decoded, -(1 << 130))
+        self.assertSequenceEqual(tail, junk)
+
     def test_decode_not_enough_data(self) -> None:
         encoded: bytes = b"\x0c\x81"
         with self.assertRaises(NotEnoughData) as err:
-- 
2.48.1