Import source to librtti

Summary:

- Import initial source

Test Plan:
NA

testsuite/meson.build

@@ -0,0 +1,13 @@
+librtti_test_srcs = [
+  'test.c',
+  'test_iter.c',
+]
+
+unity_dep = dependency('unity')
+librtti_test_deps = [dep_librtti, unity_dep]
+
+librtti_test = executable('rtti_test',
+                          librtti_test_srcs,
+                          include_directories: [incdir],
+                          dependencies: librtti_test_deps,
+                          install: true)

testsuite/test.c

@@ -0,0 +1,29 @@
+#include <stdio.h>
+#include <stdlib.h>
+
+#include <unity/unity.h>
+
+void setUp(void)
+{
+    printf("\n");
+    return;
+}
+
+void tearDown(void)
+{
+    printf("\n");
+    return;
+}
+
+extern void test_iter(void);
+
+#define TEST(x) x()
+
+int main(int argc, char* argv[])
+{
+    UNITY_BEGIN();
+
+    TEST(test_iter);
+    
+    return UNITY_END();
+}

testsuite/test_iter.c

@@ -0,0 +1,153 @@
+#include <errno.h>
+#include <stdarg.h>
+#include <unity/unity.h>
+
+#include "rtti.h"
+
+typedef struct {
+    int  count;
+    int* data;
+} myArray_t;
+
+static size_t my_array_datasize(va_list ap) { return sizeof(myArray_t); }
+
+static int my_array_init(myArray_t* a, va_list ap)
+{
+    int count;
+    int i;
+
+    count = va_arg(ap, int);
+    if (count <= 0) {
+        return -EINVAL;
+    }
+
+    a->data = (int*)calloc(count, sizeof(int));
+    if (a->data == NULL) {
+        return -ENOMEM;
+    }
+
+    a->count = count;
+    for (i = 0; i < count; i++) {
+        a->data[i] = va_arg(ap, int);
+    }
+
+    return 1;
+}
+
+static void my_array_destroy(myArray_t* a)
+{
+    if (a->data != NULL) {
+        free(a->data);
+        a->data = NULL;
+    }
+}
+
+static int my_array_make_iter(iterator_t* iter, var obj)
+{
+    iter->data = (void*)(long)0;
+
+    return ITER_OK;
+}
+
+static int my_array_iter_next(iterator_t* iter, void** data)
+{
+    myArray_t* a   = iter->v;
+    int        idx = (int)(long)iter->data;
+
+    if (idx >= a->count) {
+        /* no data */
+        return ITER_NO_DATA;
+    }
+
+    *data      = (void*)(long)a->data[idx];
+    iter->data = (void*)(long)(idx + 1);
+
+    return ITER_OK;
+}
+
+static int my_array_iter_reset(iterator_t* iter)
+{
+    iter->data = (void*)(long)0;
+
+    return ITER_OK;
+}
+
+static void my_array_iter_destroy(iterator_t* iter) { return; }
+
+static typeinfo_t myintArray
+    = { .name        = "myintArray",
+        .privateSize = 0,
+        .dataSize    = (datasize_fn_t)my_array_datasize,
+        .init        = (obj_init_fn_t)my_array_init,
+        .destroy     = (obj_destroy_fn_t)my_array_destroy,
+        .interfaces
+        = { .iter = &(intf_iterator_t) {
+                .make    = (iter_make_fn_t)my_array_make_iter,
+                .next    = (iter_next_fn_t)my_array_iter_next,
+                .reset   = (iter_reset_fn_t)my_array_iter_reset,
+                .destroy = (iter_destroy_fn_t)my_array_iter_destroy } } };
+
+static void test_array_iter(void)
+{
+    var        array = makeInstance(&myintArray, 5, 0, 1, 2, 3, 4);
+    iterator_t it;
+    int        rc, sum;
+    void*      data;
+
+    TEST_ASSERT_TRUE(array != NULL);
+
+    rc = iter_make(&it, array);
+    TEST_ASSERT_TRUE(rc == 1);
+
+    rc = iter_next(&it, (void**)&data);
+    TEST_ASSERT_TRUE(rc >= 0);
+    TEST_ASSERT_TRUE((int)(long)data == 0);
+
+    rc = iter_next(&it, (void**)&data);
+    TEST_ASSERT_TRUE(rc >= 0);
+    TEST_ASSERT_TRUE((int)(long)data == 1);
+
+    rc = iter_next(&it, (void**)&data);
+    TEST_ASSERT_TRUE(rc >= 0);
+    TEST_ASSERT_TRUE((int)(long)data == 2);
+
+    rc = iter_next(&it, (void**)&data);
+    TEST_ASSERT_TRUE(rc >= 0);
+    TEST_ASSERT_TRUE((int)(long)data == 3);
+
+    rc = iter_next(&it, (void**)&data);
+    TEST_ASSERT_TRUE(rc >= 0);
+    TEST_ASSERT_TRUE((int)(long)data == 4);
+
+    rc = iter_next(&it, (void**)&data);
+    TEST_ASSERT_TRUE(rc == ITER_NO_DATA);
+
+    sum = 0;
+    rc  = iter_reset(&it);
+    TEST_ASSERT_TRUE(rc >= 0);
+
+    for (;;) {
+        rc = iter_next(&it, &data);
+        TEST_ASSERT_TRUE(rc >= 0);
+        if (rc == ITER_NO_DATA) {
+            break;
+        }
+
+        sum += (int)(long)data;
+    }
+
+    TEST_ASSERT_TRUE(sum == 10);
+
+    iter_destroy(&it);
+
+    destroy(array);
+
+    return;
+}
+
+void test_iter(void)
+{
+    printf("\n iterator test\n\n");
+
+    RUN_TEST(test_array_iter);
+}