test(mem-alloc): add mixed allocation tests

Verify normal and aligned allocations can coexist and
obj_to_hmu works correctly for both.

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

Author: lum1n0us

tests/unit/mem-alloc/mem_alloc_test.c

@@ -208,3 +208,83 @@ test_aligned_alloc_size_not_multiple(void **state)
 
     mem_allocator_destroy(allocator);
 }
+
+/* Test: Mixed normal and aligned allocations */
+static void
+test_mixed_alloc_interleaved(void **state)
+{
+    mem_allocator_t allocator;
+    char heap_buf[128 * 1024];
+    void *normal1, *aligned1, *normal2, *aligned2;
+
+    allocator = mem_allocator_create(heap_buf, sizeof(heap_buf));
+    assert_non_null(allocator);
+
+    /* Allocate: normal -> aligned -> normal -> aligned */
+    normal1 = mem_allocator_malloc(allocator, 64);
+    assert_non_null(normal1);
+    assert_false(is_aligned_allocation(normal1));
+
+    aligned1 = mem_allocator_malloc_aligned(allocator, 128, 64);
+    assert_non_null(aligned1);
+    assert_true(is_aligned_allocation(aligned1));
+    assert_true(is_aligned(aligned1, 64));
+
+    normal2 = mem_allocator_malloc(allocator, 96);
+    assert_non_null(normal2);
+    assert_false(is_aligned_allocation(normal2));
+
+    aligned2 = mem_allocator_malloc_aligned(allocator, 256, 128);
+    assert_non_null(aligned2);
+    assert_true(is_aligned_allocation(aligned2));
+    assert_true(is_aligned(aligned2, 128));
+
+    /* Free in mixed order */
+    mem_allocator_free(allocator, normal1);
+    mem_allocator_free(allocator, aligned2);
+    mem_allocator_free(allocator, normal2);
+    mem_allocator_free(allocator, aligned1);
+
+    mem_allocator_destroy(allocator);
+}
+
+/* Test: obj_to_hmu works correctly for both types */
+static void
+test_mixed_obj_to_hmu(void **state)
+{
+    mem_allocator_t allocator;
+    char heap_buf[64 * 1024];
+    void *normal, *aligned;
+    hmu_t *hmu_normal, *hmu_aligned;
+
+    allocator = mem_allocator_create(heap_buf, sizeof(heap_buf));
+    assert_non_null(allocator);
+
+    /* Allocate both types */
+    normal = mem_allocator_malloc(allocator, 128);
+    assert_non_null(normal);
+
+    aligned = mem_allocator_malloc_aligned(allocator, 128, 64);
+    assert_non_null(aligned);
+
+    /* Get HMU pointers */
+    hmu_normal = obj_to_hmu(normal);
+    hmu_aligned = obj_to_hmu(aligned);
+
+    assert_non_null(hmu_normal);
+    assert_non_null(hmu_aligned);
+
+    /* Both should have HMU_VO type */
+    assert_int_equal(hmu_get_ut(hmu_normal), HMU_VO);
+    assert_int_equal(hmu_get_ut(hmu_aligned), HMU_VO);
+
+    /* Sizes should be reasonable */
+    assert_true(hmu_get_size(hmu_normal) >= 128);
+    assert_true(hmu_get_size(hmu_aligned) >= 128);
+
+    /* Free both */
+    mem_allocator_free(allocator, normal);
+    mem_allocator_free(allocator, aligned);
+
+    mem_allocator_destroy(allocator);
+}

tests/unit/mem-alloc/test_runner.c

@@ -22,6 +22,8 @@ main(void)
         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),
+        cmocka_unit_test(test_mixed_alloc_interleaved),
+        cmocka_unit_test(test_mixed_obj_to_hmu),
     };
 
     return cmocka_run_group_tests(tests, NULL, NULL);