test: add array test

Author: MrIndeciso

test/binaries/array_test

@@ -8,13 +8,15 @@
 
 from unittest import TestSuite, TextTestRunner, TestLoader
 
+from scripts.array_test import ArrayTest
 from scripts.basic_test import BasicTest
 from scripts.basic_struct_test import BasicStructTest
 from scripts.string_test import StringTest
 
 def test_suite():
     suite = TestSuite()
 
+    suite.addTest(TestLoader().loadTestsFromTestCase(ArrayTest))
     suite.addTest(TestLoader().loadTestsFromTestCase(BasicTest))
     suite.addTest(TestLoader().loadTestsFromTestCase(BasicStructTest))
     suite.addTest(TestLoader().loadTestsFromTestCase(StringTest))

test/run_suite.py

@@ -0,0 +1,67 @@
+#
+# This file is part of libdestruct (https://github.com/mrindeciso/libdestruct).
+# Copyright (c) 2024 Roberto Alessandro Bertolini. All rights reserved.
+# Licensed under the MIT license. See LICENSE file in the project root for details.
+#
+
+import unittest
+
+from libdebug import debugger
+from libdestruct import array, array_of, inflater, c_int, c_long, struct
+
+class ArrayTest(unittest.TestCase):
+    def test_linear_arrays_1(self):
+        d = debugger("binaries/array_test")
+
+        d.run()
+
+        bp = d.bp("do_nothing")
+
+        d.cont()
+
+        libdestruct = inflater(d.memory)
+
+        assert bp.hit_on(d)
+
+        test1 = libdestruct.inflate(array_of(c_int, 10), d.regs.rdi)
+
+        for i in range(10):
+            assert test1[i].value == i ** 2
+
+        d.cont()
+
+        class test2_t(struct):
+            a: c_int
+
+        test2 = libdestruct.inflate(array_of(test2_t, 10), d.regs.rdi)
+
+        for i in range(10):
+            assert test2[i].a.value == i ** 3
+
+        d.cont()
+
+        class test3_t(struct):
+            a: c_int
+            b: c_long
+
+        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
+
+        d.cont()
+
+        class test4_t(struct):
+            a: c_int
+            b: array = array_of(c_int, 10)
+
+        test4 = libdestruct.inflate(array_of(test4_t, 10), d.regs.rdi)
+
+        for i in range(10):
+            assert test4[i].a.value == i ** 4
+            for j in range(10):
+                assert test4[i].b[j].value == (i + 1) * j
+
+        d.kill()
+        d.terminate()

test/scripts/array_test.py

@@ -0,0 +1,65 @@
+//
+// This file is part of libdestruct (https://github.com/mrindeciso/libdestruct).
+// Copyright (c) 2024 Roberto Alessandro Bertolini. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for details.
+//
+
+// gcc -o binaries/array_test srcs/array_test.c
+
+#include <stdlib.h>
+
+#pragma pack(push, 1)
+int test1[10];
+
+struct test2 {
+    int a;
+};
+
+struct test2 test2[10];
+
+struct test3 {
+    int a;
+    long b;
+};
+
+struct test3 test3[10];
+
+struct test4 {
+    int a;
+    int b[10];
+};
+
+struct test4 test4[10];
+#pragma pack(pop)
+
+void do_nothing(void* addr)
+{
+
+}
+
+int main()
+{
+    for (int i = 0; i < 10; i++)
+        test1[i] = i * i;
+
+    for (int i = 0; i < 10; i++)
+        test2[i].a = i * i * i;
+
+    for (int i = 0; i < 10; i++) {
+        test3[i].a = 100 * i;
+        test3[i].b = 1000 * i;
+    }
+
+    for (int i = 0; i < 10; i++) {
+        test4[i].a = i * i * i * i;
+        for (int j = 0; j < 10; j++)
+            test4[i].b[j] = (i + 1) * j;
+    }
+
+    do_nothing(test1);
+    do_nothing(test2);
+    do_nothing(test3);
+    do_nothing(test4); 
+
+    return 0;
+}