feat/fix/test: improve test coverage

Author: MrIndeciso

libdestruct/c/c_str.py

@@ -12,7 +12,7 @@
 class c_str(array):
     """A C string."""
 
-    def size(self: c_str) -> int:
+    def count(self: c_str) -> int:
         """Return the size of the string."""
         size = 0
 
@@ -26,21 +26,21 @@ def size(self: c_str) -> int:
 
     def get(self: c_str, index: int = -1) -> bytes:
         """Return the character at the given index."""
-        if index != -1 and index < 0 or index >= self.size():
+        if index != -1 and index < 0 or index >= self.count():
             raise IndexError("String index out of range.")
 
         if index == -1:
-            return self.resolver.resolve(self.size(), 0)
+            return self.resolver.resolve(self.count(), 0)
 
         return bytes([self.resolver.resolve(index)[-1]])
 
     def to_bytes(self: c_str) -> bytes:
         """Return the serialized representation of the object."""
-        return self.resolver.resolve(self.size(), 0)
+        return self.resolver.resolve(self.count(), 0)
 
     def _set(self: c_str, value: bytes, index: int = -1) -> None:
         """Set the character at the given index to the given value."""
-        if index != -1 and index < 0 or index >= self.size():
+        if index != -1 and index < 0 or index >= self.count():
             raise IndexError("String index out of range.")
 
         if index == -1:
@@ -52,5 +52,5 @@ def _set(self: c_str, value: bytes, index: int = -1) -> None:
 
     def __iter__(self: c_str) -> iter:
         """Return an iterator over the string."""
-        for i in range(self.size()):
+        for i in range(self.count()):
             yield self.get(i)

libdestruct/common/array/array.py

@@ -15,12 +15,12 @@ class array(obj):
     """An array of objects."""
 
     @abstractmethod
-    def size(self: array) -> int:
+    def count(self: array) -> int:
         """Return the size of the array."""
 
     def __len__(self: array) -> int:
         """Return the size of the array."""
-        return self.size()
+        return self.count()
 
     @abstractmethod
     def get(self: array, index: int) -> object:

libdestruct/common/array/array_impl.py

@@ -34,16 +34,16 @@ def __init__(
         super().__init__(resolver)
 
         self.backing_type = backing_type
-        self.count = count
-        self.size = self.backing_type.size * self.count
+        self._count = count
+        self.size = self.backing_type.size * self._count
 
-    def size(self: array_impl) -> int:
+    def count(self: array_impl) -> int:
         """Get the size of the array."""
-        return self.size
+        return self._count
 
-    def get(self: array_impl) -> str:
-        """Get the array as a string."""
-        return f"[{', '.join(str(i) for i in self)}]"
+    def get(self: array, index: int) -> object:
+        """Return the element at the given index."""
+        return self.backing_type(self.resolver.relative_from_own(index * self.backing_type.size, 0))
 
     def _set(self: array_impl, _: list[obj]) -> None:
         """Set the array from a list."""
@@ -55,17 +55,13 @@ def set(self: array_impl, _: list[obj]) -> None:
 
     def to_bytes(self: array_impl) -> bytes:
         """Return the serialized representation of the array."""
-        return b"".join(x for x in self)
-
-    def __getitem__(self: array_impl, index: int) -> obj:
-        """Get an item from the array."""
-        return self.backing_type(self.resolver.relative_from_own(index * self.backing_type.size, 0))
+        return b"".join(bytes(x) for x in self)
 
     def __setitem__(self: array_impl, index: int, value: obj) -> None:
         """Set an item in the array."""
         raise NotImplementedError("Cannot set items in an array.")
 
     def __iter__(self: array_impl) -> Generator[obj, None, None]:
         """Iterate over the array."""
-        for i in range(self.count):
+        for i in range(self._count):
             yield self[i]

test/scripts/array_test.py

@@ -21,12 +21,18 @@ def test_linear_arrays_1(self):
 
         libdestruct = inflater(d.memory)
 
-        assert bp.hit_on(d)
+        self.assertTrue(bp.hit_on(d))
 
         test1 = libdestruct.inflate(array_of(c_int, 10), d.regs.rdi)
 
+        self.assertEqual(len(test1), 10)
+
         for i in range(10):
-            assert test1[i].value == i ** 2
+            self.assertEqual(test1[i].value, i ** 2)
+
+        self.assertEqual(bytes(test1), b"".join((i ** 2).to_bytes(4, "little") for i in range(10)))
+
+        self.assertIn(test1[0], test1)
 
         d.cont()
 
@@ -36,7 +42,7 @@ class test2_t(struct):
         test2 = libdestruct.inflate(array_of(test2_t, 10), d.regs.rdi)
 
         for i in range(10):
-            assert test2[i].a.value == i ** 3
+            self.assertEqual(test2[i].a.value, i ** 3)
 
         d.cont()
 
@@ -47,8 +53,8 @@ class test3_t(struct):
         test3 = libdestruct.inflate(array_of(test3_t, 10), d.regs.rdi)
 
         for i in range(10):
-            assert test3[i].a.value == i * 100
-            assert test3[i].b.value == i * 1000
+            self.assertEqual(test3[i].a.value, i * 100)
+            self.assertEqual(test3[i].b.value, i * 1000)
 
         d.cont()
 
@@ -59,9 +65,18 @@ class test4_t(struct):
         test4 = libdestruct.inflate(array_of(test4_t, 10), d.regs.rdi)
 
         for i in range(10):
-            assert test4[i].a.value == i ** 4
+            self.assertEqual(test4[i].a.value, i ** 4)
             for j in range(10):
-                assert test4[i].b[j].value == (i + 1) * j
+                self.assertEqual(test4[i].b[j].value, (i + 1) * j)
+
+        with self.assertRaises(NotImplementedError):
+            test4[i] = 4
+
+        with self.assertRaises(NotImplementedError):
+            test4._set([1, 2, 3])
+
+        with self.assertRaises(NotImplementedError):
+            test4.set([1, 2, 3])
 
         d.kill()
-        d.terminate()
+        d.terminate()

test/scripts/basic_test.py

@@ -42,11 +42,18 @@ def twos_complement(value, bits):
         self.assertEqual(provola3.get(), twos_complement(0xdeadbeefdeadbeef, 64))
         self.assertEqual(provola4.get(), (0xdeadbeefdeadbeef * 2) & ((1 << 64) - 1))
 
+        self.assertEqual(int(provola1), provola1.value)
+
         provola1._set(0x1)
         provola2._set(0x2)
         provola3.value = 0x3
         provola4._set(0x4)
 
+        self.assertEqual(bytes(provola1), b"\x01\x00\x00\x00")
+        self.assertEqual(bytes(provola2), b"\x02\x00\x00\x00")
+        self.assertEqual(bytes(provola3), b"\x03\x00\x00\x00\x00\x00\x00\x00")
+        self.assertEqual(bytes(provola4), b"\x04\x00\x00\x00\x00\x00\x00\x00")
+
         d.cont()
 
         assert bp2.hit_on(d)
@@ -94,6 +101,11 @@ def test_integer_type_freeze(self):
         self.assertEqual(provola3.value, 3)
         self.assertEqual(provola4.value, 4)
 
+        self.assertEqual(bytes(provola1), b"\x01\x00\x00\x00")
+        self.assertEqual(bytes(provola2), b"\x02\x00\x00\x00")
+        self.assertEqual(bytes(provola3), b"\x03\x00\x00\x00\x00\x00\x00\x00")
+        self.assertEqual(bytes(provola4), b"\x04\x00\x00\x00\x00\x00\x00\x00")
+
         self.assertRaises(ValueError, provola1.set, 0x1)
 
         d.kill()