1 files changed, 30 insertions, 50 deletions
diff --git a/tests/common/leb128.py b/tests/common/leb128.py
index db3013e..037af4d 100644
--- a/tests/common/leb128.py
+++ b/tests/common/leb128.py
@@ -1,7 +1,6 @@
 
 from chrysacase import ChrysalideTestCase
 from pychrysalide.common import pack_uleb128, unpack_uleb128, pack_leb128, unpack_leb128
-from pychrysalide.common import PackedBuffer
 
 
 class TestLEB128Values(ChrysalideTestCase):
@@ -16,34 +15,30 @@ class TestLEB128Values(ChrysalideTestCase):
             128: b'\x80\x01',
         }
 
-        for value, encoding in cases.items():
-
-            pbuf = PackedBuffer()
+        # Lecture depuis des blocs individuels
 
-            status = pack_uleb128(value, pbuf)
-            self.assertTrue(status)
+        for value, encoding in cases.items():
 
-            self.assertEqual(pbuf.payload_length, len(encoding))
+            self.assertEqual(pack_uleb128(value), encoding)
 
-            pbuf.rewind()
+            v, r = unpack_uleb128(encoding)
 
-            got = pbuf.extract(len(encoding))
+            self.assertEqual(value, v)
+            self.assertEqual(b'', r)
 
-            self.assertEqual(got, encoding)
+        # Lecture depuis un bloc commun
 
-            self.assertFalse(pbuf.more_data)
+        data = b''.join(cases.values())
 
-        for value, encoding in cases.items():
+        values = []
 
-            pbuf = PackedBuffer()
-            pbuf.extend(encoding, False)
+        while len(data) > 0:
 
-            pbuf.rewind()
+            val, data = unpack_uleb128(data)
 
-            got = unpack_uleb128(pbuf)
-            self.assertIsNotNone(got)
+            values.append(val)
 
-            self.assertEqual(got, value)
+        self.assertEqual(values, [ k for k in cases.keys() ])
 
 
     def testSignedLeb128Encoding(self):
@@ -55,54 +50,39 @@ class TestLEB128Values(ChrysalideTestCase):
             -9001: b'\xd7\xb9\x7f',
         }
 
-        for value, encoding in cases.items():
+        # Lecture depuis des blocs individuels
 
-            pbuf = PackedBuffer()
+        for value, encoding in cases.items():
 
-            status = pack_leb128(value, pbuf)
-            self.assertTrue(status)
+            self.assertEqual(pack_leb128(value), encoding)
 
-            self.assertEqual(pbuf.payload_length, len(encoding))
+            v, r = unpack_leb128(encoding)
 
-            pbuf.rewind()
+            self.assertEqual(value, v)
+            self.assertEqual(b'', r)
 
-            got = pbuf.extract(len(encoding))
+        # Lecture depuis un bloc commun
 
-            self.assertEqual(got, encoding)
+        data = b''.join(cases.values())
 
-            self.assertFalse(pbuf.more_data)
+        values = []
 
-        for value, encoding in cases.items():
+        while len(data) > 0:
 
-            pbuf = PackedBuffer()
-            pbuf.extend(encoding, False)
+            val, data = unpack_leb128(data)
 
-            pbuf.rewind()
+            values.append(val)
 
-            got = unpack_leb128(pbuf)
-            self.assertIsNotNone(got)
-
-            self.assertEqual(got, value)
+        self.assertEqual(values, [ k for k in cases.keys() ])
 
 
     def testTooBigLeb128Encodings(self):
         """Prevent overflow for LEB128 values."""
 
-        pbuf = PackedBuffer()
-        pbuf.extend(b'\x80' * 10 + b'\x7f', False)
-
-        pbuf.rewind()
-
-        got = unpack_uleb128(pbuf)
-
-        self.assertIsNone(got)
-
-        pbuf = PackedBuffer()
-        pbuf.extend(b'\x80' * 10 + b'\x7f', False)
-
-        pbuf.rewind()
+        v = unpack_uleb128(b'\x80' * 10 + b'\x7f')
 
-        got = unpack_leb128(pbuf)
+        self.assertIsNone(v)
 
-        self.assertIsNone(got)
+        v = unpack_leb128(b'\x80' * 10 + b'\x7f')
 
+        self.assertIsNone(v)