[compilcation] fix(tests): Initialize WAMR runtime in compilation tests to resolve 22 test failures

- Add proper WAMR runtime initialization in IntegrationPerformanceTest::SetUp()
- Replace FAIL() with ASSERT_TRUE() for better test practices
- Add proper cleanup in TearDown() with wasm_runtime_destroy()
- Fix all 20 IntegrationPerformanceTest cases (tests 423-442)
- Fix LLVMIntegrationOptimizationTest.test_llvm_target_machine_setup
- Fix SIMDAdvancedInstructionsTest.test_aot_emit_exception_handling_compilation

Root cause:
Tests were attempting to use WAMR functions before runtime
initialization, causing "wasm_runtime_malloc failed: memory hasn't been
initialized" errors.

Signed-off-by: Gong Pu <pu.gong@intel.com>

Author: pugong2019

tests/unit/enhanced_unit_test/compilation/test_integration_performance.cc

@@ -39,6 +39,16 @@ class IntegrationPerformanceTest : public testing::Test
 protected:
     void SetUp() override
     {
+        // Initialize WAMR runtime first
+        RuntimeInitArgs init_args;
+        memset(&init_args, 0, sizeof(RuntimeInitArgs));
+        init_args.mem_alloc_type = Alloc_With_System_Allocator;
+        
+        ASSERT_TRUE(wasm_runtime_full_init(&init_args)) << "Failed to initialize WAMR runtime";
+        
+        // Initialize AOT compiler
+        ASSERT_TRUE(aot_compiler_init()) << "Failed to initialize AOT compiler";
+        
         // Initialize test environment
         memset(&option, 0, sizeof(AOTCompOption));
 
@@ -81,9 +91,15 @@ class IntegrationPerformanceTest : public testing::Test
             wasm_module = nullptr;
         }
         if (wasm_file_buf) {
-            wasm_runtime_free(wasm_file_buf);
+            BH_FREE(wasm_file_buf);
             wasm_file_buf = nullptr;
         }
+        
+        // Destroy AOT compiler
+        aot_compiler_destroy();
+        
+        // Destroy WAMR runtime
+        wasm_runtime_destroy();
     }
 
     static void SetUpTestCase()

tests/unit/enhanced_unit_test/compilation/test_llvm_integration_optimization.cc

@@ -114,21 +114,34 @@ class LLVMIntegrationOptimizationTest : public testing::Test
         // The WASM files are copied to the build directory, so use just the filename
         wasm_file_buf = (unsigned char *)bh_read_file_to_buffer(file_name, &wasm_file_size);
         if (!wasm_file_buf || wasm_file_size == 0) {
+            printf("Failed to read WASM file: %s\n", file_name);
             return false;
         }
 
         wasm_module = wasm_runtime_load(wasm_file_buf, wasm_file_size, error_buf, sizeof(error_buf));
+        if (!wasm_module) {
+            printf("Failed to load WASM module: %s\n", error_buf);
+        }
         return wasm_module != nullptr;
     }
 
     bool create_compilation_context(AOTCompOption *test_option)
     {
-        if (!wasm_module) return false;
+        if (!wasm_module) {
+            printf("No WASM module loaded\n");
+            return false;
+        }
 
         comp_data = aot_create_comp_data(wasm_module, nullptr, false);
-        if (!comp_data) return false;
+        if (!comp_data) {
+            printf("Failed to create compilation data: %s\n", aot_get_last_error());
+            return false;
+        }
 
         comp_ctx = aot_create_comp_context(comp_data, test_option);
+        if (!comp_ctx) {
+            printf("Failed to create compilation context: %s\n", aot_get_last_error());
+        }
         return comp_ctx != nullptr;
     }
 
@@ -201,6 +214,7 @@ TEST_F(LLVMIntegrationOptimizationTest, test_llvm_target_machine_setup)
     AOTCompOption test_option = option;
     test_option.target_arch = const_cast<char*>("x86_64");
     test_option.target_abi = const_cast<char*>("gnu");
+    test_option.target_cpu = const_cast<char*>("x86-64");
     test_option.cpu_features = const_cast<char*>("+sse2,+sse3,+ssse3,+sse4.1,+sse4.2");
 
     ASSERT_TRUE(create_compilation_context(&test_option));

tests/unit/enhanced_unit_test/compilation/test_simd_advanced_instructions.cc

@@ -55,6 +55,11 @@ class SIMDAdvancedInstructionsTest : public testing::Test
             FAIL() << "Failed to initialize WAMR runtime";
         }
 
+        // Initialize AOT compiler
+        if (!aot_compiler_init()) {
+            FAIL() << "Failed to initialize AOT compiler";
+        }
+        
         // Initialize test environment
         memset(&option, 0, sizeof(AOTCompOption));
 
@@ -95,10 +100,13 @@ class SIMDAdvancedInstructionsTest : public testing::Test
             wasm_module = nullptr;
         }
         if (wasm_file_buf) {
-            wasm_runtime_free(wasm_file_buf);
+            BH_FREE(wasm_file_buf);
             wasm_file_buf = nullptr;
         }
 
+        // Destroy AOT compiler
+        aot_compiler_destroy();
+        
         // Destroy WAMR runtime
         wasm_runtime_destroy();
     }
@@ -119,15 +127,12 @@ class SIMDAdvancedInstructionsTest : public testing::Test
 
     bool LoadWasmModule()
     {
-        wasm_file_buf = (unsigned char *)bh_read_file_to_buffer(WASM_FILE, &wasm_file_size);
+        // Use just the filename since files are copied to build directory
+        const char* wasm_file = "simd_test.wasm";
+        wasm_file_buf = (unsigned char *)bh_read_file_to_buffer(wasm_file, &wasm_file_size);
         if (!wasm_file_buf) {
-            // Try alternative paths if primary path fails
-            std::string alt_path = "./simd_test.wasm";
-            wasm_file_buf = (unsigned char *)bh_read_file_to_buffer(alt_path.c_str(), &wasm_file_size);
-            if (!wasm_file_buf) {
-                printf("Failed to load WASM file from both %s and %s\n", WASM_FILE, alt_path.c_str());
-                return false;
-            }
+            printf("Failed to load WASM file: %s\n", wasm_file);
+            return false;
         }
 
         char error_buf[128];
@@ -141,16 +146,20 @@ class SIMDAdvancedInstructionsTest : public testing::Test
     bool InitializeCompilationContext()
     {
         if (!wasm_module) {
+            printf("No WASM module loaded\n");
             return false;
         }
 
-        char error_buf[128];
         comp_data = aot_create_comp_data(wasm_module, nullptr, false);
         if (!comp_data) {
+            printf("Failed to create compilation data: %s\n", aot_get_last_error());
             return false;
         }
 
         comp_ctx = aot_create_comp_context(comp_data, &option);
+        if (!comp_ctx) {
+            printf("Failed to create compilation context: %s\n", aot_get_last_error());
+        }
         return comp_ctx != nullptr;
     }
 
@@ -443,12 +452,20 @@ TEST_F(SIMDAdvancedInstructionsTest, test_aot_emit_conversion_comprehensive_type
 
 TEST_F(SIMDAdvancedInstructionsTest, test_aot_emit_exception_handling_compilation)
 {
-    // Test exception handling compilation
+    // Test exception handling compilation - use main.wasm which doesn't have SIMD
     option.enable_simd = false;  // Test without SIMD for exception focus
     option.enable_aux_stack_check = true;
     option.bounds_checks = 2;
 
-    ASSERT_TRUE(LoadWasmModule()) << "Failed to load SIMD test module";
+    // Load a non-SIMD WASM file for exception handling test
+    const char* wasm_file = "main.wasm";
+    wasm_file_buf = (unsigned char *)bh_read_file_to_buffer(wasm_file, &wasm_file_size);
+    ASSERT_TRUE(wasm_file_buf != nullptr) << "Failed to load main.wasm";
+    
+    char error_buf[128];
+    wasm_module = wasm_runtime_load(wasm_file_buf, wasm_file_size, error_buf, sizeof(error_buf));
+    ASSERT_TRUE(wasm_module != nullptr) << "Failed to load WASM module: " << error_buf;
+    
     ASSERT_TRUE(InitializeCompilationContext()) << "Failed to initialize compilation context";
 
     bool result = aot_compile_wasm(comp_ctx);