test(mem-alloc): add wasm_runtime_aligned_alloc API tests

Add comprehensive tests for the new public aligned allocation API:
- Valid allocation in POOL mode with alignment verification
- Zero size/alignment rejection
- Non-POOL mode returns NULL
- Realloc rejection for aligned allocations
- Multiple alignment values (8, 16, 32, 64, 128, 256)

Tests cover all scenarios from the implementation plan including
error handling and mode-specific behavior.

Co-Authored-By: Claude Sonnet 4.5 <noreply@anthropic.com>

Author: lum1n0us

tests/unit/mem-alloc/mem_alloc_test.c

@@ -16,6 +16,7 @@
 
 #include "mem_alloc.h"
 #include "ems_gc_internal.h"
+#include "wasm_export.h"
 
 /* Test helper: Check if pointer is aligned */
 static inline bool
@@ -364,3 +365,154 @@ test_mixed_alloc_many(void **state)
 
     mem_allocator_destroy(allocator);
 }
+
+/* Test: wasm_runtime_aligned_alloc with valid inputs in POOL mode */
+static void
+test_wasm_runtime_aligned_alloc_valid(void **state)
+{
+    RuntimeInitArgs init_args;
+    void *ptr;
+
+    memset(&init_args, 0, sizeof(RuntimeInitArgs));
+    init_args.mem_alloc_type = Alloc_With_Pool;
+    init_args.mem_alloc_option.pool.heap_buf = malloc(256 * 1024);
+    init_args.mem_alloc_option.pool.heap_size = 256 * 1024;
+
+    assert_true(wasm_runtime_init());
+    assert_true(wasm_runtime_full_init(&init_args));
+
+    /* Test valid aligned allocation */
+    ptr = wasm_runtime_aligned_alloc(128, 64);
+    assert_non_null(ptr);
+    assert_true(is_aligned(ptr, 64));
+
+    /* Free should work */
+    wasm_runtime_free(ptr);
+
+    wasm_runtime_destroy();
+    free(init_args.mem_alloc_option.pool.heap_buf);
+}
+
+/* Test: wasm_runtime_aligned_alloc with zero size */
+static void
+test_wasm_runtime_aligned_alloc_zero_size(void **state)
+{
+    RuntimeInitArgs init_args;
+    void *ptr;
+
+    memset(&init_args, 0, sizeof(RuntimeInitArgs));
+    init_args.mem_alloc_type = Alloc_With_Pool;
+    init_args.mem_alloc_option.pool.heap_buf = malloc(256 * 1024);
+    init_args.mem_alloc_option.pool.heap_size = 256 * 1024;
+
+    assert_true(wasm_runtime_init());
+    assert_true(wasm_runtime_full_init(&init_args));
+
+    /* Zero size should return NULL */
+    ptr = wasm_runtime_aligned_alloc(0, 64);
+    assert_null(ptr);
+
+    wasm_runtime_destroy();
+    free(init_args.mem_alloc_option.pool.heap_buf);
+}
+
+/* Test: wasm_runtime_aligned_alloc with zero alignment */
+static void
+test_wasm_runtime_aligned_alloc_zero_alignment(void **state)
+{
+    RuntimeInitArgs init_args;
+    void *ptr;
+
+    memset(&init_args, 0, sizeof(RuntimeInitArgs));
+    init_args.mem_alloc_type = Alloc_With_Pool;
+    init_args.mem_alloc_option.pool.heap_buf = malloc(256 * 1024);
+    init_args.mem_alloc_option.pool.heap_size = 256 * 1024;
+
+    assert_true(wasm_runtime_init());
+    assert_true(wasm_runtime_full_init(&init_args));
+
+    /* Zero alignment should return NULL */
+    ptr = wasm_runtime_aligned_alloc(128, 0);
+    assert_null(ptr);
+
+    wasm_runtime_destroy();
+    free(init_args.mem_alloc_option.pool.heap_buf);
+}
+
+/* Test: wasm_runtime_aligned_alloc in SYSTEM_ALLOCATOR mode returns NULL */
+static void
+test_wasm_runtime_aligned_alloc_system_mode(void **state)
+{
+    RuntimeInitArgs init_args;
+    void *ptr;
+
+    memset(&init_args, 0, sizeof(RuntimeInitArgs));
+    init_args.mem_alloc_type = Alloc_With_System_Allocator;
+
+    assert_true(wasm_runtime_init());
+    assert_true(wasm_runtime_full_init(&init_args));
+
+    /* Should return NULL in non-POOL mode */
+    ptr = wasm_runtime_aligned_alloc(128, 64);
+    assert_null(ptr);
+
+    wasm_runtime_destroy();
+}
+
+/* Test: wasm_runtime_realloc rejects aligned allocations */
+static void
+test_wasm_runtime_realloc_rejects_aligned(void **state)
+{
+    RuntimeInitArgs init_args;
+    void *ptr, *new_ptr;
+
+    memset(&init_args, 0, sizeof(RuntimeInitArgs));
+    init_args.mem_alloc_type = Alloc_With_Pool;
+    init_args.mem_alloc_option.pool.heap_buf = malloc(256 * 1024);
+    init_args.mem_alloc_option.pool.heap_size = 256 * 1024;
+
+    assert_true(wasm_runtime_init());
+    assert_true(wasm_runtime_full_init(&init_args));
+
+    /* Allocate with alignment */
+    ptr = wasm_runtime_aligned_alloc(128, 64);
+    assert_non_null(ptr);
+
+    /* Realloc should return NULL */
+    new_ptr = wasm_runtime_realloc(ptr, 256);
+    assert_null(new_ptr);
+
+    /* Original pointer still valid */
+    wasm_runtime_free(ptr);
+
+    wasm_runtime_destroy();
+    free(init_args.mem_alloc_option.pool.heap_buf);
+}
+
+/* Test: wasm_runtime_aligned_alloc with various alignments */
+static void
+test_wasm_runtime_aligned_alloc_multiple_alignments(void **state)
+{
+    RuntimeInitArgs init_args;
+    int alignments[] = {8, 16, 32, 64, 128, 256};
+    int num_alignments = sizeof(alignments) / sizeof(alignments[0]);
+
+    memset(&init_args, 0, sizeof(RuntimeInitArgs));
+    init_args.mem_alloc_type = Alloc_With_Pool;
+    init_args.mem_alloc_option.pool.heap_buf = malloc(512 * 1024);
+    init_args.mem_alloc_option.pool.heap_size = 512 * 1024;
+
+    assert_true(wasm_runtime_init());
+    assert_true(wasm_runtime_full_init(&init_args));
+
+    for (int i = 0; i < num_alignments; i++) {
+        int align = alignments[i];
+        void *ptr = wasm_runtime_aligned_alloc(align * 2, align);
+        assert_non_null(ptr);
+        assert_true(is_aligned(ptr, align));
+        wasm_runtime_free(ptr);
+    }
+
+    wasm_runtime_destroy();
+    free(init_args.mem_alloc_option.pool.heap_buf);
+}

tests/unit/mem-alloc/test_runner.c

@@ -26,6 +26,12 @@ main(void)
         cmocka_unit_test(test_mixed_obj_to_hmu),
         cmocka_unit_test(test_aligned_alloc_many),
         cmocka_unit_test(test_mixed_alloc_many),
+        cmocka_unit_test(test_wasm_runtime_aligned_alloc_valid),
+        cmocka_unit_test(test_wasm_runtime_aligned_alloc_zero_size),
+        cmocka_unit_test(test_wasm_runtime_aligned_alloc_zero_alignment),
+        cmocka_unit_test(test_wasm_runtime_aligned_alloc_system_mode),
+        cmocka_unit_test(test_wasm_runtime_realloc_rejects_aligned),
+        cmocka_unit_test(test_wasm_runtime_aligned_alloc_multiple_alignments),
     };
 
     return cmocka_run_group_tests(tests, NULL, NULL);