test(mem-alloc): add alignment validation tests

Verify invalid alignments and size requirements are enforced.
Fix alignment validation to reject zero.

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

Author: lum1n0us

core/shared/mem-alloc/ems/ems_alloc.c

@@ -651,8 +651,8 @@ gc_alloc_vo_aligned_internal(void *vheap, gc_size_t size, gc_size_t alignment,
     max_alignment = (uint32_t)os_getpagesize();
 
     /* Validation */
-    if ((alignment & (alignment - 1)) != 0) {
-        /* Not power of 2 */
+    if (alignment == 0 || (alignment & (alignment - 1)) != 0) {
+        /* Zero or not power of 2 */
         return NULL;
     }
 

tests/unit/mem-alloc/mem_alloc_test.c

@@ -148,3 +148,63 @@ test_normal_realloc_works(void **state)
     mem_allocator_free(allocator, new_ptr);
     mem_allocator_destroy(allocator);
 }
+
+/* Test: Invalid alignments (not power of 2 or zero) */
+static void
+test_aligned_alloc_invalid_not_power_of_2(void **state)
+{
+    mem_allocator_t allocator;
+    char heap_buf[64 * 1024];
+    void *ptr;
+
+    allocator = mem_allocator_create(heap_buf, sizeof(heap_buf));
+    assert_non_null(allocator);
+
+    /* These should all fail (zero or not power of 2) */
+    int invalid_alignments[] = {0, 3, 5, 7, 9, 15, 17, 100};
+    for (int i = 0; i < sizeof(invalid_alignments) / sizeof(invalid_alignments[0]); i++) {
+        ptr = mem_allocator_malloc_aligned(allocator, 128, invalid_alignments[i]);
+        assert_null(ptr);
+    }
+
+    /* Small powers of 2 should succeed (adjusted to GC_MIN_ALIGNMENT) */
+    ptr = mem_allocator_malloc_aligned(allocator, 8, 1);
+    assert_non_null(ptr);
+    mem_allocator_free(allocator, ptr);
+
+    ptr = mem_allocator_malloc_aligned(allocator, 8, 2);
+    assert_non_null(ptr);
+    mem_allocator_free(allocator, ptr);
+
+    ptr = mem_allocator_malloc_aligned(allocator, 8, 4);
+    assert_non_null(ptr);
+    mem_allocator_free(allocator, ptr);
+
+    mem_allocator_destroy(allocator);
+}
+
+/* Test: Size must be multiple of alignment */
+static void
+test_aligned_alloc_size_not_multiple(void **state)
+{
+    mem_allocator_t allocator;
+    char heap_buf[64 * 1024];
+    void *ptr;
+
+    allocator = mem_allocator_create(heap_buf, sizeof(heap_buf));
+    assert_non_null(allocator);
+
+    /* Size not multiple of alignment - should fail */
+    ptr = mem_allocator_malloc_aligned(allocator, 100, 64);
+    assert_null(ptr);
+
+    ptr = mem_allocator_malloc_aligned(allocator, 65, 64);
+    assert_null(ptr);
+
+    /* Size is multiple - should succeed */
+    ptr = mem_allocator_malloc_aligned(allocator, 128, 64);
+    assert_non_null(ptr);
+    mem_allocator_free(allocator, ptr);
+
+    mem_allocator_destroy(allocator);
+}

tests/unit/mem-alloc/test_runner.c

@@ -20,6 +20,8 @@ main(void)
         cmocka_unit_test(test_aligned_alloc_valid_alignments),
         cmocka_unit_test(test_realloc_rejects_aligned),
         cmocka_unit_test(test_normal_realloc_works),
+        cmocka_unit_test(test_aligned_alloc_invalid_not_power_of_2),
+        cmocka_unit_test(test_aligned_alloc_size_not_multiple),
     };
 
     return cmocka_run_group_tests(tests, NULL, NULL);