diff --git a/spm/cactus_mm/cactus_mm_main.c b/spm/cactus_mm/cactus_mm_main.c
index 8452e65..bd64ccc 100644
--- a/spm/cactus_mm/cactus_mm_main.c
+++ b/spm/cactus_mm/cactus_mm_main.c
@@ -114,10 +114,7 @@
 	 */
 	misc_tests();
 	system_setup_tests();
-	/*
-	 * TODO: The following tests fail in the CI:
-	 * mem_attr_changes_tests(boot_info);
-	 */
+	mem_attr_changes_tests(boot_info);
 
 	/*
 	 * Handle secure service requests.
diff --git a/tftf/tests/tests-spm-mm.xml b/tftf/tests/tests-spm-mm.xml
index 79f67b9..3447385 100644
--- a/tftf/tests/tests-spm-mm.xml
+++ b/tftf/tests/tests-spm-mm.xml
@@ -14,10 +14,8 @@
               function="test_secure_partition_interrupt_by_ns" />
     <testcase name="SPM secondary CPUs sequential test"
               function="test_secure_partition_secondary_cores_seq" />
-<!-- TODO: This test fails in the CI.
     <testcase name="SPM secondary CPUs simultaneous test"
               function="test_secure_partition_secondary_cores_sim" />
--->
   </testsuite>
 
 </testsuites>
