From 373ba2534c10b7290cb505e99da1dd831ea1f99a Mon Sep 17 00:00:00 2001
From: Tanner Gooding <tagoo@outlook.com>
Date: Mon, 19 Nov 2018 18:28:48 -0800
Subject: [PATCH 1/3] Updating the VectorNotSupportedTest to throw on failure

---
 .../General/Shared/VectorNotSupportedTest.template              | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/tests/src/JIT/HardwareIntrinsics/General/Shared/VectorNotSupportedTest.template b/tests/src/JIT/HardwareIntrinsics/General/Shared/VectorNotSupportedTest.template
index bd4a888bc6cf..d0d6ef61757d 100644
--- a/tests/src/JIT/HardwareIntrinsics/General/Shared/VectorNotSupportedTest.template
+++ b/tests/src/JIT/HardwareIntrinsics/General/Shared/VectorNotSupportedTest.template
@@ -35,6 +35,8 @@ namespace JIT.HardwareIntrinsics.General
             {
                 TestLibrary.TestFramework.LogInformation($"{Name}: RunNotSupportedScenario failed to throw NotSupportedException.");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                throw new Exception("One or more scenarios did not complete as expected.");
             }
         }
     }

From 3a71e6117623d2c53b1ef1faff707717469d6512 Mon Sep 17 00:00:00 2001
From: Tanner Gooding <tagoo@outlook.com>
Date: Mon, 19 Nov 2018 18:52:37 -0800
Subject: [PATCH 2/3] Updating the HWIntrinsic test templates to check success
 on a per-scenario basis

---
 .../General/Shared/VectorAsTest.template      |  8 +++--
 .../Shared/VectorCreateElementTest.template   |  8 +++--
 .../General/Shared/VectorCreateTest.template  | 10 ++++--
 .../Shared/VectorCreateVectorTest.template    | 10 ++++--
 .../General/Shared/VectorExtendTest.template  | 10 ++++--
 .../VectorGetAndWithElementTest.template      | 26 ++++++++-------
 ...VectorGetAndWithLowerAndUpperTest.template | 32 ++++++++++++++-----
 .../Shared/VectorToScalarTest.template        |  4 +--
 .../General/Shared/VectorZeroTest.template    |  8 +++--
 .../X86/Shared/AesBinOpTest.template          | 18 ++++++++---
 .../X86/Shared/AesImmOpTest.template          | 23 +++++++++----
 .../X86/Shared/AesUnOpTest.template           | 19 ++++++++---
 .../X86/Shared/AlternatingBinOpTest.template  | 19 ++++++++---
 .../X86/Shared/AlternatingTernOpTest.template | 19 ++++++++---
 .../X86/Shared/BooleanBinOpTest.template      | 13 +++++---
 .../X86/Shared/BooleanCmpOpTest.template      | 13 +++++---
 .../X86/Shared/BooleanTwoCmpOpTest.template   | 13 +++++---
 .../X86/Shared/BooleanUnOpTest.template       | 13 +++++---
 .../X86/Shared/ExtractScalarTest.template     | 17 +++++++---
 .../X86/Shared/ExtractStoreTest.template      | 19 ++++++++---
 .../X86/Shared/ExtractVector128Test.template  | 19 ++++++++---
 .../X86/Shared/GenericUnOpTest.template       | 19 ++++++++---
 .../X86/Shared/HorizontalBinOpTest.template   | 19 ++++++++---
 .../X86/Shared/ImmBinOpTest.template          | 19 ++++++++---
 .../X86/Shared/ImmUnOpTest.template           | 19 ++++++++---
 .../X86/Shared/InsertLoadTest.template        | 19 ++++++++---
 .../X86/Shared/InsertScalarTest.template      | 16 +++++++---
 .../X86/Shared/InsertVector128Test.template   | 19 ++++++++---
 .../X86/Shared/LoadBinOpTest.template         | 19 ++++++++---
 .../X86/Shared/LoadUnOpTest.template          | 10 ++++--
 .../X86/Shared/PclmulqdqOpTest.template       | 18 ++++++++---
 .../X86/Shared/ScalarBinOpTest.template       | 11 +++++--
 .../X86/Shared/ScalarSimdUnOpTest.template    | 19 ++++++++---
 .../X86/Shared/ScalarUnOpTest.template        | 11 +++++--
 .../Shared/SimdScalarUnOpConvTest.template    | 17 +++++++---
 .../X86/Shared/SimdScalarUnOpTest.template    | 17 +++++++---
 .../X86/Shared/SimpleBinOpTest.template       | 19 ++++++++---
 .../X86/Shared/SimpleTernOpTest.template      | 19 ++++++++---
 .../X86/Shared/SimpleUnOpConvTest.template    | 19 ++++++++---
 .../X86/Shared/SimpleUnOpTest.template        | 19 ++++++++---
 .../X86/Shared/StoreBinOpTest.template        | 19 ++++++++---
 41 files changed, 488 insertions(+), 180 deletions(-)

diff --git a/tests/src/JIT/HardwareIntrinsics/General/Shared/VectorAsTest.template b/tests/src/JIT/HardwareIntrinsics/General/Shared/VectorAsTest.template
index bd28520ac564..8e9fe4373e68 100644
--- a/tests/src/JIT/HardwareIntrinsics/General/Shared/VectorAsTest.template
+++ b/tests/src/JIT/HardwareIntrinsics/General/Shared/VectorAsTest.template
@@ -218,21 +218,25 @@ namespace JIT.HardwareIntrinsics.General
 
         private void ValidateResult({BaseType}[] resultElements, {BaseType}[] valueElements, Type targetType, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             for (var i = 0; i < ElementCount; i++)
             {
                 if (resultElements[i] != valueElements[i])
                 {
-                    Succeeded = false;
+                    succeeded = false;
                     break;
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{VectorType}<{BaseType}>.{Method}{targetType.Name}: {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"   value: ({string.Join(", ", valueElements)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", resultElements)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/General/Shared/VectorCreateElementTest.template b/tests/src/JIT/HardwareIntrinsics/General/Shared/VectorCreateElementTest.template
index ec0954552373..a5259ede1435 100644
--- a/tests/src/JIT/HardwareIntrinsics/General/Shared/VectorCreateElementTest.template
+++ b/tests/src/JIT/HardwareIntrinsics/General/Shared/VectorCreateElementTest.template
@@ -88,21 +88,25 @@ namespace JIT.HardwareIntrinsics.General
 
         private void ValidateResult({BaseType}[] resultElements, {BaseType}[] expectedValues, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             for (var i = 0; i < ElementCount; i++)
             {
                 if (resultElements[i] != expectedValues[i])
                 {
-                    Succeeded = false;
+                    succeeded = false;
                     break;
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{Isa}.{Method}({BaseType}): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"   value: ({string.Join(", ", expectedValues)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", resultElements)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/General/Shared/VectorCreateTest.template b/tests/src/JIT/HardwareIntrinsics/General/Shared/VectorCreateTest.template
index c3173575f2e4..7e770b6a432d 100644
--- a/tests/src/JIT/HardwareIntrinsics/General/Shared/VectorCreateTest.template
+++ b/tests/src/JIT/HardwareIntrinsics/General/Shared/VectorCreateTest.template
@@ -74,9 +74,11 @@ namespace JIT.HardwareIntrinsics.General
 
         private void ValidateResult({BaseType}[] resultElements, {BaseType} expectedValue, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if ({ValidateFirstResult})
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -84,18 +86,20 @@ namespace JIT.HardwareIntrinsics.General
                 {
                     if ({ValidateRemainingResults})
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{Isa}.{Method}({BaseType}): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"   value: {expectedValue}");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", resultElements)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/General/Shared/VectorCreateVectorTest.template b/tests/src/JIT/HardwareIntrinsics/General/Shared/VectorCreateVectorTest.template
index fc6ab0aeb6d7..cb9f95c3a4a7 100644
--- a/tests/src/JIT/HardwareIntrinsics/General/Shared/VectorCreateVectorTest.template
+++ b/tests/src/JIT/HardwareIntrinsics/General/Shared/VectorCreateVectorTest.template
@@ -84,11 +84,13 @@ namespace JIT.HardwareIntrinsics.General
 
         private void ValidateResult({BaseType}[] resultElements, {BaseType} expectedLowerValue, {BaseType} expectedUpperValue, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             for (var i = 0; i < ElementCount / 2; i++)
             {
                 if (resultElements[i] != expectedLowerValue)
                 {
-                    Succeeded = false;
+                    succeeded = false;
                     break;
                 }
             }
@@ -97,18 +99,20 @@ namespace JIT.HardwareIntrinsics.General
             {
                 if (resultElements[i] != expectedUpperValue)
                 {
-                    Succeeded = false;
+                    succeeded = false;
                     break;
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{Isa}.{Method}({BaseType}): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"   lower: {expectedLowerValue}");
                 TestLibrary.TestFramework.LogInformation($"   upper: {expectedUpperValue}");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", resultElements)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/General/Shared/VectorExtendTest.template b/tests/src/JIT/HardwareIntrinsics/General/Shared/VectorExtendTest.template
index 307b6ba65038..6b39f961cb5f 100644
--- a/tests/src/JIT/HardwareIntrinsics/General/Shared/VectorExtendTest.template
+++ b/tests/src/JIT/HardwareIntrinsics/General/Shared/VectorExtendTest.template
@@ -97,11 +97,13 @@ namespace JIT.HardwareIntrinsics.General
 
         private void ValidateResult({BaseType}[] result, {BaseType}[] values, bool isUnsafe, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             for (int i = 0; i < ElementCount; i++)
             {
                 if (result[i] != values[i])
                 {
-                    Succeeded = false;
+                    succeeded = false;
                     break;
                 }
             }
@@ -112,18 +114,20 @@ namespace JIT.HardwareIntrinsics.General
                 {
                     if (result[i] != 0)
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{VectorType}<{BaseType}>.{Method}{(isUnsafe ? "Unsafe" : "")}(): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"   value: ({string.Join(", ", values)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/General/Shared/VectorGetAndWithElementTest.template b/tests/src/JIT/HardwareIntrinsics/General/Shared/VectorGetAndWithElementTest.template
index 605e85795c34..0faab95ddd41 100644
--- a/tests/src/JIT/HardwareIntrinsics/General/Shared/VectorGetAndWithElementTest.template
+++ b/tests/src/JIT/HardwareIntrinsics/General/Shared/VectorGetAndWithElementTest.template
@@ -74,10 +74,10 @@ namespace JIT.HardwareIntrinsics.General
 
             if (!succeeded)
             {
-                Succeeded = false;
-
                 TestLibrary.TestFramework.LogInformation($"{VectorType}<{BaseType}.GetElement({imm}): {nameof(RunBasicScenario)} failed to throw ArgumentOutOfRangeException.");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
 
             succeeded = !expectedOutOfRangeException;
@@ -96,10 +96,10 @@ namespace JIT.HardwareIntrinsics.General
 
             if (!succeeded)
             {
-                Succeeded = false;
-
                 TestLibrary.TestFramework.LogInformation($"{VectorType}<{BaseType}.WithElement({imm}): {nameof(RunBasicScenario)} failed to throw ArgumentOutOfRangeException.");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
 
@@ -133,10 +133,10 @@ namespace JIT.HardwareIntrinsics.General
 
             if (!succeeded)
             {
-                Succeeded = false;
-
                 TestLibrary.TestFramework.LogInformation($"{VectorType}<{BaseType}.GetElement({imm}): {nameof(RunReflectionScenario)} failed to throw ArgumentOutOfRangeException.");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
 
             succeeded = !expectedOutOfRangeException;
@@ -158,10 +158,10 @@ namespace JIT.HardwareIntrinsics.General
 
             if (!succeeded)
             {
-                Succeeded = false;
-
                 TestLibrary.TestFramework.LogInformation($"{VectorType}<{BaseType}.WithElement({imm}): {nameof(RunReflectionScenario)} failed to throw ArgumentOutOfRangeException.");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
 
@@ -196,27 +196,31 @@ namespace JIT.HardwareIntrinsics.General
 
         private void ValidateWithResult({BaseType}[] result, {BaseType}[] values, {BaseType} insertedValue, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             for (int i = 0; i < ElementCount; i++)
             {
                 if ((i != {Imm}) && (result[i] != values[i]))
                 {
-                    Succeeded = false;
+                    succeeded = false;
                     break;
                 }
             }
 
             if (result[{Imm}] != insertedValue)
             {
-                Succeeded = false;
+                succeeded = false;
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{VectorType}<{BaseType}.WithElement({Imm}): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"   value: ({string.Join(", ", values)})");
                 TestLibrary.TestFramework.LogInformation($"  insert: insertedValue");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/General/Shared/VectorGetAndWithLowerAndUpperTest.template b/tests/src/JIT/HardwareIntrinsics/General/Shared/VectorGetAndWithLowerAndUpperTest.template
index 626e8d8505a6..80dee3c6d458 100644
--- a/tests/src/JIT/HardwareIntrinsics/General/Shared/VectorGetAndWithLowerAndUpperTest.template
+++ b/tests/src/JIT/HardwareIntrinsics/General/Shared/VectorGetAndWithLowerAndUpperTest.template
@@ -108,38 +108,46 @@ namespace JIT.HardwareIntrinsics.General
 
         private void ValidateGetResult({BaseType}[] lowerResult, {BaseType}[] upperResult, {BaseType}[] values, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             for (int i = 0; i < ElementCount / 2; i++)
             {
                 if (lowerResult[i] != values[i])
                 {
-                    Succeeded = false;
+                    succeeded = false;
                     break;
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{VectorType}<{BaseType}>.GetLower(): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"   value: ({string.Join(", ", values)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", lowerResult)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
 
+            succeeded = true;
+
             for (int i = ElementCount / 2; i < ElementCount; i++)
             {
                 if (upperResult[i - (ElementCount / 2)] != values[i])
                 {
-                    Succeeded = false;
+                    succeeded = false;
                     break;
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{VectorType}<{BaseType}>.GetUpper(): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"   value: ({string.Join(", ", values)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", upperResult)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
 
@@ -152,38 +160,46 @@ namespace JIT.HardwareIntrinsics.General
 
         private void ValidateWithResult({BaseType}[] result, {BaseType}[] values, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             for (int i = 0; i < ElementCount / 2; i++)
             {
                 if (result[i] != values[i + (ElementCount / 2)])
                 {
-                    Succeeded = false;
+                    succeeded = false;
                     break;
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{VectorType}<{BaseType}.WithLower(): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"   value: ({string.Join(", ", values)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
 
+            succeeded = true;
+
             for (int i = ElementCount / 2; i < ElementCount; i++)
             {
                 if (result[i] != values[i - (ElementCount / 2)])
                 {
-                    Succeeded = false;
+                    succeeded = false;
                     break;
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{VectorType}<{BaseType}.WithUpper(): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"   value: ({string.Join(", ", values)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/General/Shared/VectorToScalarTest.template b/tests/src/JIT/HardwareIntrinsics/General/Shared/VectorToScalarTest.template
index 70e4ea9778b1..0202049f36a2 100644
--- a/tests/src/JIT/HardwareIntrinsics/General/Shared/VectorToScalarTest.template
+++ b/tests/src/JIT/HardwareIntrinsics/General/Shared/VectorToScalarTest.template
@@ -84,12 +84,12 @@ namespace JIT.HardwareIntrinsics.General
         {
             if (result != values[0])
             {
-                Succeeded = false;
-
                 TestLibrary.TestFramework.LogInformation($"{VectorType}<{BaseType}>.{Method}(): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"  values: ({string.Join(", ", values)})");
                 TestLibrary.TestFramework.LogInformation($"  result: {result}");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/General/Shared/VectorZeroTest.template b/tests/src/JIT/HardwareIntrinsics/General/Shared/VectorZeroTest.template
index 693fbaee7602..215eec240884 100644
--- a/tests/src/JIT/HardwareIntrinsics/General/Shared/VectorZeroTest.template
+++ b/tests/src/JIT/HardwareIntrinsics/General/Shared/VectorZeroTest.template
@@ -73,20 +73,24 @@ namespace JIT.HardwareIntrinsics.General
 
         private void ValidateResult({BaseType}[] resultElements, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+        
             for (var i = 0; i < ElementCount; i++)
             {
                 if (resultElements[i] != 0)
                 {
-                    Succeeded = false;
+                    succeeded = false;
                     break;
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{VectorType}.{Method}({BaseType}): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", resultElements)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Shared/AesBinOpTest.template b/tests/src/JIT/HardwareIntrinsics/X86/Shared/AesBinOpTest.template
index 3f0876177382..015fca9fef9c 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Shared/AesBinOpTest.template
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Shared/AesBinOpTest.template
@@ -330,7 +330,7 @@ namespace JIT.HardwareIntrinsics.X86
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -338,7 +338,12 @@ namespace JIT.HardwareIntrinsics.X86
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -355,19 +360,24 @@ namespace JIT.HardwareIntrinsics.X86
         
         private void ValidateResult({RetBaseType}[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             for (int i = 0; i < result.Length; i++)
             {
                 if (result[i] != _expectedRet[i] )
                 {
-                    Succeeded = false;
+                    succeeded = false;
                 } 
             }
-            if (!Succeeded)
+
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof({Isa})}.{nameof({Isa}.{Method})}<{RetBaseType}>({Op1VectorType}<{Op1BaseType}>, {Op2VectorType}<{Op2BaseType}>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"  expectedRet: ({string.Join(", ", _expectedRet)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Shared/AesImmOpTest.template b/tests/src/JIT/HardwareIntrinsics/X86/Shared/AesImmOpTest.template
index 87452cdf9bc9..7db814e63949 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Shared/AesImmOpTest.template
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Shared/AesImmOpTest.template
@@ -317,7 +317,7 @@ namespace JIT.HardwareIntrinsics.X86
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -325,7 +325,12 @@ namespace JIT.HardwareIntrinsics.X86
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -341,21 +346,25 @@ namespace JIT.HardwareIntrinsics.X86
 
         private void ValidateResult({RetBaseType}[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             for (int i = 0; i < result.Length; i++)
             {
                 if (result[i] != _expectedRet[i] )
-                    {
-                        Succeeded = false;
-		    	break;
-                    }
+                {
+                    succeeded = false;
+                    break;
+                }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof({Isa})}.{nameof({Isa}.{Method})}<{RetBaseType}>({Op1VectorType}<{Op1BaseType}>, {Imm}): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"  expectedRet: ({string.Join(", ", _expectedRet)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Shared/AesUnOpTest.template b/tests/src/JIT/HardwareIntrinsics/X86/Shared/AesUnOpTest.template
index 8679423494a7..21cb032cb589 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Shared/AesUnOpTest.template
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Shared/AesUnOpTest.template
@@ -310,7 +310,7 @@ namespace JIT.HardwareIntrinsics.X86
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -318,7 +318,12 @@ namespace JIT.HardwareIntrinsics.X86
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -335,21 +340,25 @@ namespace JIT.HardwareIntrinsics.X86
 
         private void ValidateResult({RetBaseType}[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             for (int i = 0; i < result.Length; i++)
             {
                 if (result[i] != _expectedRet[i] )
                 {
-                    Succeeded = false;
-		    break;
+                    succeeded = false;
+                    break;
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof({Isa})}.{nameof({Isa}.{Method})}<{RetBaseType}>({Op1VectorType}<{Op1BaseType}>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"  expectedRet: ({string.Join(", ", _expectedRet)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Shared/AlternatingBinOpTest.template b/tests/src/JIT/HardwareIntrinsics/X86/Shared/AlternatingBinOpTest.template
index ea415242f1d7..d0a2c2018315 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Shared/AlternatingBinOpTest.template
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Shared/AlternatingBinOpTest.template
@@ -334,7 +334,7 @@ namespace JIT.HardwareIntrinsics.X86
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -342,7 +342,12 @@ namespace JIT.HardwareIntrinsics.X86
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -374,28 +379,32 @@ namespace JIT.HardwareIntrinsics.X86
 
         private void ValidateResult({Op1BaseType}[] left, {Op2BaseType}[] right, {RetBaseType}[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             for (var i = 0; i < RetElementCount; i += 2)
             {
                 if ({ValidateFirstResult})
                 {
-                    Succeeded = false;
+                    succeeded = false;
                     break;
                 }
 
                 if ({ValidateRemainingResults})
                 {
-                    Succeeded = false;
+                    succeeded = false;
                     break;
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof({Isa})}.{nameof({Isa}.{Method})}<{RetBaseType}>({Op1VectorType}<{Op1BaseType}>, {Op2VectorType}<{Op2BaseType}>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Shared/AlternatingTernOpTest.template b/tests/src/JIT/HardwareIntrinsics/X86/Shared/AlternatingTernOpTest.template
index c9fb8778c081..db80cc2aca09 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Shared/AlternatingTernOpTest.template
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Shared/AlternatingTernOpTest.template
@@ -356,7 +356,7 @@ namespace JIT.HardwareIntrinsics.X86
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -364,7 +364,12 @@ namespace JIT.HardwareIntrinsics.X86
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -400,22 +405,24 @@ namespace JIT.HardwareIntrinsics.X86
 
         private void ValidateResult({Op1BaseType}[] firstOp, {Op2BaseType}[] secondOp, {Op3BaseType}[] thirdOp, {RetBaseType}[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             for (var i = 0; i < RetElementCount; i += 2)
             {
                 if ({ValidateFirstResult})
                 {
-                    Succeeded = false;
+                    succeeded = false;
                     break;
                 }
 
                 if ({ValidateRemainingResults})
                 {
-                    Succeeded = false;
+                    succeeded = false;
                     break;
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof({Isa})}.{nameof({Isa}.{Method})}<{RetBaseType}>({Op1VectorType}<{Op1BaseType}>, {Op2VectorType}<{Op2BaseType}>, {Op3VectorType}<{Op3BaseType}>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"   firstOp: ({string.Join(", ", firstOp)})");
@@ -423,6 +430,8 @@ namespace JIT.HardwareIntrinsics.X86
                 TestLibrary.TestFramework.LogInformation($"   thirdOp: ({string.Join(", ", thirdOp)})");
                 TestLibrary.TestFramework.LogInformation($"    result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Shared/BooleanBinOpTest.template b/tests/src/JIT/HardwareIntrinsics/X86/Shared/BooleanBinOpTest.template
index d0afd86db844..35a8f063286e 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Shared/BooleanBinOpTest.template
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Shared/BooleanBinOpTest.template
@@ -329,7 +329,7 @@ namespace JIT.HardwareIntrinsics.X86
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -337,7 +337,12 @@ namespace JIT.HardwareIntrinsics.X86
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -374,13 +379,13 @@ namespace JIT.HardwareIntrinsics.X86
 
             if (expectedResult != result)
             {
-                Succeeded = false;
-
                 TestLibrary.TestFramework.LogInformation($"{nameof({Isa})}.{nameof({Isa}.{Method})}<{RetBaseType}>({Op1VectorType}<{Op1BaseType}>, {Op2VectorType}<{Op2BaseType}>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Shared/BooleanCmpOpTest.template b/tests/src/JIT/HardwareIntrinsics/X86/Shared/BooleanCmpOpTest.template
index 2aacabb2a484..424619c4815a 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Shared/BooleanCmpOpTest.template
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Shared/BooleanCmpOpTest.template
@@ -317,7 +317,7 @@ namespace JIT.HardwareIntrinsics.X86
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -325,7 +325,12 @@ namespace JIT.HardwareIntrinsics.X86
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -355,13 +360,13 @@ namespace JIT.HardwareIntrinsics.X86
         {
             if ({ValidateFirstResult})
             {
-                Succeeded = false;
-
                 TestLibrary.TestFramework.LogInformation($"{nameof({Isa})}.{nameof({Isa}.{Method})}<{RetBaseType}>({Op1VectorType}<{Op1BaseType}>, {Op2VectorType}<{Op2BaseType}>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Shared/BooleanTwoCmpOpTest.template b/tests/src/JIT/HardwareIntrinsics/X86/Shared/BooleanTwoCmpOpTest.template
index 502f5d03269e..6930a4de3394 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Shared/BooleanTwoCmpOpTest.template
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Shared/BooleanTwoCmpOpTest.template
@@ -329,7 +329,7 @@ namespace JIT.HardwareIntrinsics.X86
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -337,7 +337,12 @@ namespace JIT.HardwareIntrinsics.X86
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -381,13 +386,13 @@ namespace JIT.HardwareIntrinsics.X86
 
             if (((expectedResult1 == false) && (expectedResult2 == false)) != result)
             {
-                Succeeded = false;
-
                 TestLibrary.TestFramework.LogInformation($"{nameof({Isa})}.{nameof({Isa}.{Method})}<{RetBaseType}>({Op1VectorType}<{Op1BaseType}>, {Op2VectorType}<{Op2BaseType}>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Shared/BooleanUnOpTest.template b/tests/src/JIT/HardwareIntrinsics/X86/Shared/BooleanUnOpTest.template
index 84d4b272b1c3..5924e48d39e4 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Shared/BooleanUnOpTest.template
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Shared/BooleanUnOpTest.template
@@ -296,7 +296,7 @@ namespace JIT.HardwareIntrinsics.X86
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -304,7 +304,12 @@ namespace JIT.HardwareIntrinsics.X86
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -337,12 +342,12 @@ namespace JIT.HardwareIntrinsics.X86
 
             if (expectedResult != result)
             {
-                Succeeded = false;
-
                 TestLibrary.TestFramework.LogInformation($"{nameof({Isa})}.{nameof({Isa}.{Method})}<{RetBaseType}>({Op1VectorType}<{Op1BaseType}>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    value: ({string.Join(", ", value)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Shared/ExtractScalarTest.template b/tests/src/JIT/HardwareIntrinsics/X86/Shared/ExtractScalarTest.template
index 7ee25cd6c05d..dff553889ea5 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Shared/ExtractScalarTest.template
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Shared/ExtractScalarTest.template
@@ -319,7 +319,7 @@ namespace JIT.HardwareIntrinsics.X86
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -327,7 +327,12 @@ namespace JIT.HardwareIntrinsics.X86
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -355,17 +360,21 @@ namespace JIT.HardwareIntrinsics.X86
 
         private void ValidateResult({Op1BaseType}[] firstOp, {RetBaseType}[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if ({ValidateFirstResult})
             {
-                Succeeded = false;
+                succeeded = false;
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof({Isa})}.{nameof({Isa}.{Method})}<{RetBaseType}>({Op1VectorType}<{Op1BaseType}><9>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"  firstOp: ({string.Join(", ", firstOp)})");
                 TestLibrary.TestFramework.LogInformation($"   result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Shared/ExtractStoreTest.template b/tests/src/JIT/HardwareIntrinsics/X86/Shared/ExtractStoreTest.template
index 817c52fa8cc4..74032ef804eb 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Shared/ExtractStoreTest.template
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Shared/ExtractStoreTest.template
@@ -306,7 +306,7 @@ namespace JIT.HardwareIntrinsics.X86
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -314,7 +314,12 @@ namespace JIT.HardwareIntrinsics.X86
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -342,9 +347,11 @@ namespace JIT.HardwareIntrinsics.X86
 
         private void ValidateResult({Op1BaseType}[] firstOp, {RetBaseType}[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if ({ValidateFirstResult})
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -352,18 +359,20 @@ namespace JIT.HardwareIntrinsics.X86
                 {
                     if ({ValidateRemainingResults})
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof({Isa})}.{nameof({Isa}.{Method})}<{RetBaseType}>({Op1VectorType}<{Op1BaseType}><9>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"  firstOp: ({string.Join(", ", firstOp)})");
                 TestLibrary.TestFramework.LogInformation($"   result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Shared/ExtractVector128Test.template b/tests/src/JIT/HardwareIntrinsics/X86/Shared/ExtractVector128Test.template
index 74f7a44a7913..9069c797d02d 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Shared/ExtractVector128Test.template
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Shared/ExtractVector128Test.template
@@ -319,7 +319,7 @@ namespace JIT.HardwareIntrinsics.X86
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -327,7 +327,12 @@ namespace JIT.HardwareIntrinsics.X86
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -355,9 +360,11 @@ namespace JIT.HardwareIntrinsics.X86
 
         private void ValidateResult({Op1BaseType}[] firstOp, {RetBaseType}[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if ({ValidateFirstResult})
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -365,18 +372,20 @@ namespace JIT.HardwareIntrinsics.X86
                 {
                     if ({ValidateRemainingResults})
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof({Isa})}.{nameof({Isa}.{Method})}<{RetBaseType}>({Op1VectorType}<{Op1BaseType}><9>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"  firstOp: ({string.Join(", ", firstOp)})");
                 TestLibrary.TestFramework.LogInformation($"   result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Shared/GenericUnOpTest.template b/tests/src/JIT/HardwareIntrinsics/X86/Shared/GenericUnOpTest.template
index 22eb00321031..7c815bdc3f89 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Shared/GenericUnOpTest.template
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Shared/GenericUnOpTest.template
@@ -315,7 +315,7 @@ namespace JIT.HardwareIntrinsics.X86
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -323,7 +323,12 @@ namespace JIT.HardwareIntrinsics.X86
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -351,9 +356,11 @@ namespace JIT.HardwareIntrinsics.X86
 
         private void ValidateResult({Op1BaseType}[] firstOp, {RetBaseType}[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if ({ValidateFirstResult})
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -361,18 +368,20 @@ namespace JIT.HardwareIntrinsics.X86
                 {
                     if ({ValidateRemainingResults})
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof({Isa})}.{nameof({Isa}.{Method})}<{RetBaseType}>({Op1VectorType}<{Op1BaseType}>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"  firstOp: ({string.Join(", ", firstOp)})");
                 TestLibrary.TestFramework.LogInformation($"   result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Shared/HorizontalBinOpTest.template b/tests/src/JIT/HardwareIntrinsics/X86/Shared/HorizontalBinOpTest.template
index 1f1e0e546eae..a3ae33c064b9 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Shared/HorizontalBinOpTest.template
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Shared/HorizontalBinOpTest.template
@@ -334,7 +334,7 @@ namespace JIT.HardwareIntrinsics.X86
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -342,7 +342,12 @@ namespace JIT.HardwareIntrinsics.X86
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -374,6 +379,8 @@ namespace JIT.HardwareIntrinsics.X86
 
         private void ValidateResult({Op1BaseType}[] left, {Op2BaseType}[] right, {RetBaseType}[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             for (var outer = 0; outer < (LargestVectorSize / 16); outer++)
             {
                 for (var inner = 0; inner < (8 / sizeof({RetBaseType})); inner++)
@@ -384,25 +391,27 @@ namespace JIT.HardwareIntrinsics.X86
 
                     if ({ValidateFirstResult})
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
 
                     if ({ValidateRemainingResults})
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof({Isa})}.{nameof({Isa}.{Method})}<{RetBaseType}>({Op1VectorType}<{Op1BaseType}>, {Op2VectorType}<{Op2BaseType}>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Shared/ImmBinOpTest.template b/tests/src/JIT/HardwareIntrinsics/X86/Shared/ImmBinOpTest.template
index 9c37a0152393..469d1aaddb41 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Shared/ImmBinOpTest.template
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Shared/ImmBinOpTest.template
@@ -341,7 +341,7 @@ namespace JIT.HardwareIntrinsics.X86
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -349,7 +349,12 @@ namespace JIT.HardwareIntrinsics.X86
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -381,9 +386,11 @@ namespace JIT.HardwareIntrinsics.X86
 
         private void ValidateResult({Op1BaseType}[] left, {Op2BaseType}[] right, {RetBaseType}[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if ({ValidateFirstResult})
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -391,19 +398,21 @@ namespace JIT.HardwareIntrinsics.X86
                 {
                     if ({ValidateRemainingResults})
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof({Isa})}.{nameof({Isa}.{Method})}<{RetBaseType}>({Op1VectorType}<{Op1BaseType}>.{Imm}, {Op2VectorType}<{Op2BaseType}>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Shared/ImmUnOpTest.template b/tests/src/JIT/HardwareIntrinsics/X86/Shared/ImmUnOpTest.template
index e0d63e685064..11f2bd953b6e 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Shared/ImmUnOpTest.template
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Shared/ImmUnOpTest.template
@@ -319,7 +319,7 @@ namespace JIT.HardwareIntrinsics.X86
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -327,7 +327,12 @@ namespace JIT.HardwareIntrinsics.X86
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -355,9 +360,11 @@ namespace JIT.HardwareIntrinsics.X86
 
         private void ValidateResult({Op1BaseType}[] firstOp, {RetBaseType}[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if ({ValidateFirstResult})
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -365,18 +372,20 @@ namespace JIT.HardwareIntrinsics.X86
                 {
                     if ({ValidateRemainingResults})
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof({Isa})}.{nameof({Isa}.{Method})}<{RetBaseType}>({Op1VectorType}<{Op1BaseType}><9>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"  firstOp: ({string.Join(", ", firstOp)})");
                 TestLibrary.TestFramework.LogInformation($"   result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Shared/InsertLoadTest.template b/tests/src/JIT/HardwareIntrinsics/X86/Shared/InsertLoadTest.template
index cd277f7c8cff..4f49a63ef532 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Shared/InsertLoadTest.template
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Shared/InsertLoadTest.template
@@ -343,7 +343,7 @@ namespace JIT.HardwareIntrinsics.X86
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -351,7 +351,12 @@ namespace JIT.HardwareIntrinsics.X86
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -383,9 +388,11 @@ namespace JIT.HardwareIntrinsics.X86
 
         private void ValidateResult({Op1BaseType}[] left, {Op2BaseType}[] right, {RetBaseType}[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if ({ValidateFirstResult})
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -393,19 +400,21 @@ namespace JIT.HardwareIntrinsics.X86
                 {
                     if ({ValidateRemainingResults})
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof({Isa})}.{nameof({Isa}.{Method})}<{RetBaseType}>({Op1VectorType}<{Op1BaseType}>, {Op2VectorType}<{Op2BaseType}>.{Imm}): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Shared/InsertScalarTest.template b/tests/src/JIT/HardwareIntrinsics/X86/Shared/InsertScalarTest.template
index 8176b23400d2..59c752fc3e0b 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Shared/InsertScalarTest.template
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Shared/InsertScalarTest.template
@@ -326,7 +326,7 @@ namespace JIT.HardwareIntrinsics.X86
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -334,7 +334,12 @@ namespace JIT.HardwareIntrinsics.X86
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -362,22 +367,25 @@ namespace JIT.HardwareIntrinsics.X86
 
         private void ValidateResult({Op1BaseType}[] firstOp, {RetBaseType}[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
 
             for (var i = 0; i < RetElementCount; i++)
             {
                 if ({ValidateFirstResult})
                 {
-                    Succeeded = false;
+                    succeeded = false;
                     break;
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof({Isa})}.{nameof({Isa}.{Method})}<{RetBaseType}>({Op1VectorType}<{Op1BaseType}><9>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"  firstOp: ({string.Join(", ", firstOp)})");
                 TestLibrary.TestFramework.LogInformation($"   result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Shared/InsertVector128Test.template b/tests/src/JIT/HardwareIntrinsics/X86/Shared/InsertVector128Test.template
index 28019b973ba4..7e0088ffa983 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Shared/InsertVector128Test.template
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Shared/InsertVector128Test.template
@@ -343,7 +343,7 @@ namespace JIT.HardwareIntrinsics.X86
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -351,7 +351,12 @@ namespace JIT.HardwareIntrinsics.X86
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -383,9 +388,11 @@ namespace JIT.HardwareIntrinsics.X86
 
         private void ValidateResult({Op1BaseType}[] left, {Op2BaseType}[] right, {RetBaseType}[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if ({ValidateFirstResult})
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -393,19 +400,21 @@ namespace JIT.HardwareIntrinsics.X86
                 {
                     if ({ValidateRemainingResults})
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof({Isa})}.{nameof({Isa}.{Method})}<{RetBaseType}>({Op1VectorType}<{Op1BaseType}>, {Op2VectorType}<{Op2BaseType}>.{Imm}): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Shared/LoadBinOpTest.template b/tests/src/JIT/HardwareIntrinsics/X86/Shared/LoadBinOpTest.template
index 48ec635c2d48..fac4d38e8b59 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Shared/LoadBinOpTest.template
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Shared/LoadBinOpTest.template
@@ -331,7 +331,7 @@ namespace JIT.HardwareIntrinsics.X86
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -339,7 +339,12 @@ namespace JIT.HardwareIntrinsics.X86
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -371,9 +376,11 @@ namespace JIT.HardwareIntrinsics.X86
 
         private void ValidateResult({Op1BaseType}[] left, {Op2BaseType}[] right, {RetBaseType}[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if ({ValidateFirstResult})
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -381,19 +388,21 @@ namespace JIT.HardwareIntrinsics.X86
                 {
                     if ({ValidateRemainingResults})
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof({Isa})}.{nameof({Isa}.{Method})}<{RetBaseType}>({Op1BaseType}*, {Op2VectorType}<{Op2BaseType}>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Shared/LoadUnOpTest.template b/tests/src/JIT/HardwareIntrinsics/X86/Shared/LoadUnOpTest.template
index d01804dd3e3a..a921f60eab71 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Shared/LoadUnOpTest.template
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Shared/LoadUnOpTest.template
@@ -133,9 +133,11 @@ namespace JIT.HardwareIntrinsics.X86
 
         private void ValidateResult({Op1BaseType}[] firstOp, {RetBaseType}[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if ({ValidateFirstResult})
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -143,18 +145,20 @@ namespace JIT.HardwareIntrinsics.X86
                 {
                     if ({ValidateRemainingResults})
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof({Isa})}.{nameof({Isa}.{Method})}<{RetBaseType}>({Op1VectorType}<{Op1BaseType}>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"  firstOp: ({string.Join(", ", firstOp)})");
                 TestLibrary.TestFramework.LogInformation($"   result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Shared/PclmulqdqOpTest.template b/tests/src/JIT/HardwareIntrinsics/X86/Shared/PclmulqdqOpTest.template
index 352cdc39b157..4076bac85c21 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Shared/PclmulqdqOpTest.template
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Shared/PclmulqdqOpTest.template
@@ -334,7 +334,7 @@ namespace JIT.HardwareIntrinsics.X86
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -342,7 +342,12 @@ namespace JIT.HardwareIntrinsics.X86
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -358,19 +363,24 @@ namespace JIT.HardwareIntrinsics.X86
 
         private void ValidateResult({RetBaseType}[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             for (int i = 0; i < result.Length; i++)
             {
                 if (result[i] != _expectedRet[i] )
                 {
-                    Succeeded = false;
+                    succeeded = false;
                 } 
             }
-            if (!Succeeded)
+
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof({Isa})}.{nameof({Isa}.{Method})}<{RetBaseType}>({Op1VectorType}<{Op1BaseType}>, {Imm}): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"  expectedRet: ({string.Join(", ", _expectedRet)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
 
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Shared/ScalarBinOpTest.template b/tests/src/JIT/HardwareIntrinsics/X86/Shared/ScalarBinOpTest.template
index 063edd5a02e0..5821f08869c0 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Shared/ScalarBinOpTest.template
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Shared/ScalarBinOpTest.template
@@ -204,7 +204,7 @@ namespace JIT.HardwareIntrinsics.X86
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -212,7 +212,12 @@ namespace JIT.HardwareIntrinsics.X86
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -229,6 +234,8 @@ namespace JIT.HardwareIntrinsics.X86
                 TestLibrary.TestFramework.LogInformation($"   right: {right}");
                 TestLibrary.TestFramework.LogInformation($"  result: {result}");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Shared/ScalarSimdUnOpTest.template b/tests/src/JIT/HardwareIntrinsics/X86/Shared/ScalarSimdUnOpTest.template
index 4b418c35d3fe..27ca02d179b8 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Shared/ScalarSimdUnOpTest.template
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Shared/ScalarSimdUnOpTest.template
@@ -207,7 +207,7 @@ namespace JIT.HardwareIntrinsics.X86
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -215,7 +215,12 @@ namespace JIT.HardwareIntrinsics.X86
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -230,9 +235,11 @@ namespace JIT.HardwareIntrinsics.X86
 
         private void ValidateResult({Op1BaseType} firstOp, {RetBaseType}[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if ({ValidateFirstResult})
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -240,18 +247,20 @@ namespace JIT.HardwareIntrinsics.X86
                 {
                     if ({ValidateRemainingResults})
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof({Isa})}.{nameof({Isa}.{Method})}<{RetBaseType}>({Op1VectorType}<{Op1BaseType}>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"  firstOp: ({string.Join(", ", firstOp)})");
                 TestLibrary.TestFramework.LogInformation($"   result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Shared/ScalarUnOpTest.template b/tests/src/JIT/HardwareIntrinsics/X86/Shared/ScalarUnOpTest.template
index 145c98c35a10..e9f20f37376b 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Shared/ScalarUnOpTest.template
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Shared/ScalarUnOpTest.template
@@ -191,7 +191,7 @@ namespace JIT.HardwareIntrinsics.X86
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -199,7 +199,12 @@ namespace JIT.HardwareIntrinsics.X86
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -215,6 +220,8 @@ namespace JIT.HardwareIntrinsics.X86
                 TestLibrary.TestFramework.LogInformation($"    data: {data}");
                 TestLibrary.TestFramework.LogInformation($"  result: {result}");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Shared/SimdScalarUnOpConvTest.template b/tests/src/JIT/HardwareIntrinsics/X86/Shared/SimdScalarUnOpConvTest.template
index f01d6c3f84c4..2819dcd81d5f 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Shared/SimdScalarUnOpConvTest.template
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Shared/SimdScalarUnOpConvTest.template
@@ -296,7 +296,7 @@ namespace JIT.HardwareIntrinsics.X86
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -304,7 +304,12 @@ namespace JIT.HardwareIntrinsics.X86
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -324,17 +329,21 @@ namespace JIT.HardwareIntrinsics.X86
 
         private void ValidateResult({Op1BaseType}[] firstOp, {RetBaseType} result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if ({ValidateFirstResult})
             {
-                Succeeded = false;
+                succeeded = false;
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof({Isa})}.{nameof({Isa}.{Method})}<{RetBaseType}>({Op1VectorType}<{Op1BaseType}>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"  firstOp: ({string.Join(", ", firstOp)})");
                 TestLibrary.TestFramework.LogInformation($"   result: result");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Shared/SimdScalarUnOpTest.template b/tests/src/JIT/HardwareIntrinsics/X86/Shared/SimdScalarUnOpTest.template
index 4a850e9d1d97..f42d4b800359 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Shared/SimdScalarUnOpTest.template
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Shared/SimdScalarUnOpTest.template
@@ -296,7 +296,7 @@ namespace JIT.HardwareIntrinsics.X86
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -304,7 +304,12 @@ namespace JIT.HardwareIntrinsics.X86
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -324,17 +329,21 @@ namespace JIT.HardwareIntrinsics.X86
 
         private void ValidateResult({Op1BaseType}[] firstOp, {RetBaseType} result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if ({ValidateFirstResult})
             {
-                Succeeded = false;
+                succeeded = false;
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof({Isa})}.{nameof({Isa}.{Method})}<{RetBaseType}>({Op1VectorType}<{Op1BaseType}>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"  firstOp: ({string.Join(", ", firstOp)})");
                 TestLibrary.TestFramework.LogInformation($"   result: result");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Shared/SimpleBinOpTest.template b/tests/src/JIT/HardwareIntrinsics/X86/Shared/SimpleBinOpTest.template
index 611f45e1a278..366eaca5bf7c 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Shared/SimpleBinOpTest.template
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Shared/SimpleBinOpTest.template
@@ -334,7 +334,7 @@ namespace JIT.HardwareIntrinsics.X86
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -342,7 +342,12 @@ namespace JIT.HardwareIntrinsics.X86
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -374,9 +379,11 @@ namespace JIT.HardwareIntrinsics.X86
 
         private void ValidateResult({Op1BaseType}[] left, {Op2BaseType}[] right, {RetBaseType}[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if ({ValidateFirstResult})
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -384,19 +391,21 @@ namespace JIT.HardwareIntrinsics.X86
                 {
                     if ({ValidateRemainingResults})
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof({Isa})}.{nameof({Isa}.{Method})}<{RetBaseType}>({Op1VectorType}<{Op1BaseType}>, {Op2VectorType}<{Op2BaseType}>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Shared/SimpleTernOpTest.template b/tests/src/JIT/HardwareIntrinsics/X86/Shared/SimpleTernOpTest.template
index 77966b7ee904..f79da6d24ed7 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Shared/SimpleTernOpTest.template
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Shared/SimpleTernOpTest.template
@@ -356,7 +356,7 @@ namespace JIT.HardwareIntrinsics.X86
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -364,7 +364,12 @@ namespace JIT.HardwareIntrinsics.X86
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -400,9 +405,11 @@ namespace JIT.HardwareIntrinsics.X86
 
         private void ValidateResult({Op1BaseType}[] firstOp, {Op2BaseType}[] secondOp, {Op3BaseType}[] thirdOp, {RetBaseType}[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if ({ValidateFirstResult})
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -410,13 +417,13 @@ namespace JIT.HardwareIntrinsics.X86
                 {
                     if ({ValidateRemainingResults})
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof({Isa})}.{nameof({Isa}.{Method})}<{RetBaseType}>({Op1VectorType}<{Op1BaseType}>, {Op2VectorType}<{Op2BaseType}>, {Op3VectorType}<{Op3BaseType}>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"   firstOp: ({string.Join(", ", firstOp)})");
@@ -424,6 +431,8 @@ namespace JIT.HardwareIntrinsics.X86
                 TestLibrary.TestFramework.LogInformation($"   thirdOp: ({string.Join(", ", thirdOp)})");
                 TestLibrary.TestFramework.LogInformation($"    result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Shared/SimpleUnOpConvTest.template b/tests/src/JIT/HardwareIntrinsics/X86/Shared/SimpleUnOpConvTest.template
index 68c23f4bd5c4..dd6fa708684d 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Shared/SimpleUnOpConvTest.template
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Shared/SimpleUnOpConvTest.template
@@ -312,7 +312,7 @@ namespace JIT.HardwareIntrinsics.X86
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -320,7 +320,12 @@ namespace JIT.HardwareIntrinsics.X86
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -348,9 +353,11 @@ namespace JIT.HardwareIntrinsics.X86
 
         private void ValidateResult({Op1BaseType}[] firstOp, {RetBaseType}[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if ({ValidateFirstResult})
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -358,18 +365,20 @@ namespace JIT.HardwareIntrinsics.X86
                 {
                     if ({ValidateRemainingResults})
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof({Isa})}.{nameof({Isa}.{Method})}<{RetBaseType}>({Op1VectorType}<{Op1BaseType}>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"  firstOp: ({string.Join(", ", firstOp)})");
                 TestLibrary.TestFramework.LogInformation($"   result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Shared/SimpleUnOpTest.template b/tests/src/JIT/HardwareIntrinsics/X86/Shared/SimpleUnOpTest.template
index 938aeed7e289..59442938b790 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Shared/SimpleUnOpTest.template
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Shared/SimpleUnOpTest.template
@@ -312,7 +312,7 @@ namespace JIT.HardwareIntrinsics.X86
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -320,7 +320,12 @@ namespace JIT.HardwareIntrinsics.X86
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -348,9 +353,11 @@ namespace JIT.HardwareIntrinsics.X86
 
         private void ValidateResult({Op1BaseType}[] firstOp, {RetBaseType}[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if ({ValidateFirstResult})
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -358,18 +365,20 @@ namespace JIT.HardwareIntrinsics.X86
                 {
                     if ({ValidateRemainingResults})
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof({Isa})}.{nameof({Isa}.{Method})}<{RetBaseType}>({Op1VectorType}<{Op1BaseType}>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"  firstOp: ({string.Join(", ", firstOp)})");
                 TestLibrary.TestFramework.LogInformation($"   result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Shared/StoreBinOpTest.template b/tests/src/JIT/HardwareIntrinsics/X86/Shared/StoreBinOpTest.template
index aecb58b794d3..ca64c183580e 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Shared/StoreBinOpTest.template
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Shared/StoreBinOpTest.template
@@ -326,7 +326,7 @@ namespace JIT.HardwareIntrinsics.X86
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -334,7 +334,12 @@ namespace JIT.HardwareIntrinsics.X86
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -366,9 +371,11 @@ namespace JIT.HardwareIntrinsics.X86
 
         private void ValidateResult({Op1BaseType}[] left, {Op2BaseType}[] right, {RetBaseType}[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if ({ValidateFirstResult})
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -376,19 +383,21 @@ namespace JIT.HardwareIntrinsics.X86
                 {
                     if ({ValidateRemainingResults})
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof({Isa})}.{nameof({Isa}.{Method})}<{RetBaseType}>({Op1VectorType}<{Op1BaseType}>, {Op2VectorType}<{Op2BaseType}>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }

From be3e3c16f5aaabf0b48bb3e1f30d7b64b707764e Mon Sep 17 00:00:00 2001
From: Tanner Gooding <tagoo@outlook.com>
Date: Mon, 19 Nov 2018 18:53:59 -0800
Subject: [PATCH 3/3] Regenerating the templated HWIntrinsic tests

---
 .../NotSupported/Vector128BooleanAsByte.cs    |  2 ++
 .../NotSupported/Vector128BooleanAsDouble.cs  |  2 ++
 .../Vector128BooleanAsGeneric_Boolean.cs      |  2 ++
 .../Vector128BooleanAsGeneric_Byte.cs         |  2 ++
 .../Vector128BooleanAsGeneric_Double.cs       |  2 ++
 .../Vector128BooleanAsGeneric_Int16.cs        |  2 ++
 .../Vector128BooleanAsGeneric_Int32.cs        |  2 ++
 .../Vector128BooleanAsGeneric_Int64.cs        |  2 ++
 .../Vector128BooleanAsGeneric_SByte.cs        |  2 ++
 .../Vector128BooleanAsGeneric_Single.cs       |  2 ++
 .../Vector128BooleanAsGeneric_UInt16.cs       |  2 ++
 .../Vector128BooleanAsGeneric_UInt32.cs       |  2 ++
 .../Vector128BooleanAsGeneric_UInt64.cs       |  2 ++
 .../NotSupported/Vector128BooleanAsInt16.cs   |  2 ++
 .../NotSupported/Vector128BooleanAsInt32.cs   |  2 ++
 .../NotSupported/Vector128BooleanAsInt64.cs   |  2 ++
 .../NotSupported/Vector128BooleanAsSByte.cs   |  2 ++
 .../NotSupported/Vector128BooleanAsSingle.cs  |  2 ++
 .../NotSupported/Vector128BooleanAsUInt16.cs  |  2 ++
 .../NotSupported/Vector128BooleanAsUInt32.cs  |  2 ++
 .../NotSupported/Vector128BooleanAsUInt64.cs  |  2 ++
 .../Vector128ByteAsGeneric_Boolean.cs         |  2 ++
 .../Vector128DoubleAsGeneric_Boolean.cs       |  2 ++
 .../NotSupported/Vector128GetElement0.cs      |  2 ++
 .../Vector128GetElementMaxValue.cs            |  2 ++
 .../Vector128GetElementNegativeOne.cs         |  2 ++
 .../General/NotSupported/Vector128GetLower.cs |  2 ++
 .../General/NotSupported/Vector128GetUpper.cs |  2 ++
 .../Vector128Int16AsGeneric_Boolean.cs        |  2 ++
 .../Vector128Int32AsGeneric_Boolean.cs        |  2 ++
 .../Vector128Int64AsGeneric_Boolean.cs        |  2 ++
 .../Vector128SByteAsGeneric_Boolean.cs        |  2 ++
 .../Vector128SingleAsGeneric_Boolean.cs       |  2 ++
 .../General/NotSupported/Vector128ToScalar.cs |  2 ++
 .../NotSupported/Vector128ToVector256.cs      |  2 ++
 .../Vector128ToVector256Unsafe.cs             |  2 ++
 .../Vector128UInt16AsGeneric_Boolean.cs       |  2 ++
 .../Vector128UInt32AsGeneric_Boolean.cs       |  2 ++
 .../Vector128UInt64AsGeneric_Boolean.cs       |  2 ++
 .../NotSupported/Vector128WithElement0.cs     |  2 ++
 .../Vector128WithElementMaxValue.cs           |  2 ++
 .../Vector128WithElementNegativeOne.cs        |  2 ++
 .../NotSupported/Vector128WithLower.cs        |  2 ++
 .../NotSupported/Vector128WithUpper.cs        |  2 ++
 .../General/NotSupported/Vector128Zero.cs     |  2 ++
 .../NotSupported/Vector256BooleanAsByte.cs    |  2 ++
 .../NotSupported/Vector256BooleanAsDouble.cs  |  2 ++
 .../Vector256BooleanAsGeneric_Boolean.cs      |  2 ++
 .../Vector256BooleanAsGeneric_Byte.cs         |  2 ++
 .../Vector256BooleanAsGeneric_Double.cs       |  2 ++
 .../Vector256BooleanAsGeneric_Int16.cs        |  2 ++
 .../Vector256BooleanAsGeneric_Int32.cs        |  2 ++
 .../Vector256BooleanAsGeneric_Int64.cs        |  2 ++
 .../Vector256BooleanAsGeneric_SByte.cs        |  2 ++
 .../Vector256BooleanAsGeneric_Single.cs       |  2 ++
 .../Vector256BooleanAsGeneric_UInt16.cs       |  2 ++
 .../Vector256BooleanAsGeneric_UInt32.cs       |  2 ++
 .../Vector256BooleanAsGeneric_UInt64.cs       |  2 ++
 .../NotSupported/Vector256BooleanAsInt16.cs   |  2 ++
 .../NotSupported/Vector256BooleanAsInt32.cs   |  2 ++
 .../NotSupported/Vector256BooleanAsInt64.cs   |  2 ++
 .../NotSupported/Vector256BooleanAsSByte.cs   |  2 ++
 .../NotSupported/Vector256BooleanAsSingle.cs  |  2 ++
 .../NotSupported/Vector256BooleanAsUInt16.cs  |  2 ++
 .../NotSupported/Vector256BooleanAsUInt32.cs  |  2 ++
 .../NotSupported/Vector256BooleanAsUInt64.cs  |  2 ++
 .../Vector256ByteAsGeneric_Boolean.cs         |  2 ++
 .../Vector256DoubleAsGeneric_Boolean.cs       |  2 ++
 .../NotSupported/Vector256GetElement0.cs      |  2 ++
 .../Vector256GetElementMaxValue.cs            |  2 ++
 .../Vector256GetElementNegativeOne.cs         |  2 ++
 .../General/NotSupported/Vector256GetLower.cs |  2 ++
 .../General/NotSupported/Vector256GetUpper.cs |  2 ++
 .../Vector256Int16AsGeneric_Boolean.cs        |  2 ++
 .../Vector256Int32AsGeneric_Boolean.cs        |  2 ++
 .../Vector256Int64AsGeneric_Boolean.cs        |  2 ++
 .../Vector256SByteAsGeneric_Boolean.cs        |  2 ++
 .../Vector256SingleAsGeneric_Boolean.cs       |  2 ++
 .../General/NotSupported/Vector256ToScalar.cs |  2 ++
 .../Vector256UInt16AsGeneric_Boolean.cs       |  2 ++
 .../Vector256UInt32AsGeneric_Boolean.cs       |  2 ++
 .../Vector256UInt64AsGeneric_Boolean.cs       |  2 ++
 .../NotSupported/Vector256WithElement0.cs     |  2 ++
 .../Vector256WithElementMaxValue.cs           |  2 ++
 .../Vector256WithElementNegativeOne.cs        |  2 ++
 .../NotSupported/Vector256WithLower.cs        |  2 ++
 .../NotSupported/Vector256WithUpper.cs        |  2 ++
 .../General/NotSupported/Vector256Zero.cs     |  2 ++
 .../NotSupported/Vector64BooleanAsByte.cs     |  2 ++
 .../NotSupported/Vector64BooleanAsDouble.cs   |  2 ++
 .../Vector64BooleanAsGeneric_Boolean.cs       |  2 ++
 .../Vector64BooleanAsGeneric_Byte.cs          |  2 ++
 .../Vector64BooleanAsGeneric_Double.cs        |  2 ++
 .../Vector64BooleanAsGeneric_Int16.cs         |  2 ++
 .../Vector64BooleanAsGeneric_Int32.cs         |  2 ++
 .../Vector64BooleanAsGeneric_Int64.cs         |  2 ++
 .../Vector64BooleanAsGeneric_SByte.cs         |  2 ++
 .../Vector64BooleanAsGeneric_Single.cs        |  2 ++
 .../Vector64BooleanAsGeneric_UInt16.cs        |  2 ++
 .../Vector64BooleanAsGeneric_UInt32.cs        |  2 ++
 .../Vector64BooleanAsGeneric_UInt64.cs        |  2 ++
 .../NotSupported/Vector64BooleanAsInt16.cs    |  2 ++
 .../NotSupported/Vector64BooleanAsInt32.cs    |  2 ++
 .../NotSupported/Vector64BooleanAsInt64.cs    |  2 ++
 .../NotSupported/Vector64BooleanAsSByte.cs    |  2 ++
 .../NotSupported/Vector64BooleanAsSingle.cs   |  2 ++
 .../NotSupported/Vector64BooleanAsUInt16.cs   |  2 ++
 .../NotSupported/Vector64BooleanAsUInt32.cs   |  2 ++
 .../NotSupported/Vector64BooleanAsUInt64.cs   |  2 ++
 .../Vector64ByteAsGeneric_Boolean.cs          |  2 ++
 .../Vector64DoubleAsGeneric_Boolean.cs        |  2 ++
 .../NotSupported/Vector64GetElement0.cs       |  2 ++
 .../Vector64GetElementMaxValue.cs             |  2 ++
 .../Vector64GetElementNegativeOne.cs          |  2 ++
 .../Vector64Int16AsGeneric_Boolean.cs         |  2 ++
 .../Vector64Int32AsGeneric_Boolean.cs         |  2 ++
 .../Vector64Int64AsGeneric_Boolean.cs         |  2 ++
 .../Vector64SByteAsGeneric_Boolean.cs         |  2 ++
 .../Vector64SingleAsGeneric_Boolean.cs        |  2 ++
 .../General/NotSupported/Vector64ToScalar.cs  |  2 ++
 .../NotSupported/Vector64ToVector128.cs       |  2 ++
 .../NotSupported/Vector64ToVector128Unsafe.cs |  2 ++
 .../Vector64UInt16AsGeneric_Boolean.cs        |  2 ++
 .../Vector64UInt32AsGeneric_Boolean.cs        |  2 ++
 .../Vector64UInt64AsGeneric_Boolean.cs        |  2 ++
 .../NotSupported/Vector64WithElement0.cs      |  2 ++
 .../Vector64WithElementMaxValue.cs            |  2 ++
 .../Vector64WithElementNegativeOne.cs         |  2 ++
 .../General/NotSupported/Vector64Zero.cs      |  2 ++
 .../General/Vector128/Create.Byte.cs          | 10 ++++--
 .../General/Vector128/Create.Double.cs        | 10 ++++--
 .../General/Vector128/Create.Int16.cs         | 10 ++++--
 .../General/Vector128/Create.Int32.cs         | 10 ++++--
 .../General/Vector128/Create.Int64.cs         | 10 ++++--
 .../General/Vector128/Create.SByte.cs         | 10 ++++--
 .../General/Vector128/Create.Single.cs        | 10 ++++--
 .../General/Vector128/Create.UInt16.cs        | 10 ++++--
 .../General/Vector128/Create.UInt32.cs        | 10 ++++--
 .../General/Vector128/Create.UInt64.cs        | 10 ++++--
 .../General/Vector128/CreateElement.Byte.cs   |  8 +++--
 .../General/Vector128/CreateElement.Double.cs |  8 +++--
 .../General/Vector128/CreateElement.Int16.cs  |  8 +++--
 .../General/Vector128/CreateElement.Int32.cs  |  8 +++--
 .../General/Vector128/CreateElement.Int64.cs  |  8 +++--
 .../General/Vector128/CreateElement.SByte.cs  |  8 +++--
 .../General/Vector128/CreateElement.Single.cs |  8 +++--
 .../General/Vector128/CreateElement.UInt16.cs |  8 +++--
 .../General/Vector128/CreateElement.UInt32.cs |  8 +++--
 .../General/Vector128/CreateElement.UInt64.cs |  8 +++--
 .../General/Vector128/CreateScalar.Byte.cs    | 10 ++++--
 .../General/Vector128/CreateScalar.Double.cs  | 10 ++++--
 .../General/Vector128/CreateScalar.Int16.cs   | 10 ++++--
 .../General/Vector128/CreateScalar.Int32.cs   | 10 ++++--
 .../General/Vector128/CreateScalar.Int64.cs   | 10 ++++--
 .../General/Vector128/CreateScalar.SByte.cs   | 10 ++++--
 .../General/Vector128/CreateScalar.Single.cs  | 10 ++++--
 .../General/Vector128/CreateScalar.UInt16.cs  | 10 ++++--
 .../General/Vector128/CreateScalar.UInt32.cs  | 10 ++++--
 .../General/Vector128/CreateScalar.UInt64.cs  | 10 ++++--
 .../Vector128/CreateScalarUnsafe.Byte.cs      | 10 ++++--
 .../Vector128/CreateScalarUnsafe.Double.cs    | 10 ++++--
 .../Vector128/CreateScalarUnsafe.Int16.cs     | 10 ++++--
 .../Vector128/CreateScalarUnsafe.Int32.cs     | 10 ++++--
 .../Vector128/CreateScalarUnsafe.Int64.cs     | 10 ++++--
 .../Vector128/CreateScalarUnsafe.SByte.cs     | 10 ++++--
 .../Vector128/CreateScalarUnsafe.Single.cs    | 10 ++++--
 .../Vector128/CreateScalarUnsafe.UInt16.cs    | 10 ++++--
 .../Vector128/CreateScalarUnsafe.UInt32.cs    | 10 ++++--
 .../Vector128/CreateScalarUnsafe.UInt64.cs    | 10 ++++--
 .../General/Vector128/CreateVector.Byte.cs    | 10 ++++--
 .../General/Vector128/CreateVector.Double.cs  | 10 ++++--
 .../General/Vector128/CreateVector.Int16.cs   | 10 ++++--
 .../General/Vector128/CreateVector.Int32.cs   | 10 ++++--
 .../General/Vector128/CreateVector.Int64.cs   | 10 ++++--
 .../General/Vector128/CreateVector.SByte.cs   | 10 ++++--
 .../General/Vector128/CreateVector.Single.cs  | 10 ++++--
 .../General/Vector128/CreateVector.UInt16.cs  | 10 ++++--
 .../General/Vector128/CreateVector.UInt32.cs  | 10 ++++--
 .../General/Vector128/CreateVector.UInt64.cs  | 10 ++++--
 .../General/Vector128_1/As.Byte.cs            |  8 +++--
 .../General/Vector128_1/As.Double.cs          |  8 +++--
 .../General/Vector128_1/As.Int16.cs           |  8 +++--
 .../General/Vector128_1/As.Int32.cs           |  8 +++--
 .../General/Vector128_1/As.Int64.cs           |  8 +++--
 .../General/Vector128_1/As.SByte.cs           |  8 +++--
 .../General/Vector128_1/As.Single.cs          |  8 +++--
 .../General/Vector128_1/As.UInt16.cs          |  8 +++--
 .../General/Vector128_1/As.UInt32.cs          |  8 +++--
 .../General/Vector128_1/As.UInt64.cs          |  8 +++--
 .../Vector128_1/GetAndWithElement.Byte.0.cs   | 26 ++++++++-------
 .../Vector128_1/GetAndWithElement.Byte.15.cs  | 26 ++++++++-------
 .../Vector128_1/GetAndWithElement.Byte.7.cs   | 26 ++++++++-------
 .../Vector128_1/GetAndWithElement.Double.0.cs | 26 ++++++++-------
 .../Vector128_1/GetAndWithElement.Double.1.cs | 26 ++++++++-------
 .../Vector128_1/GetAndWithElement.Int16.0.cs  | 26 ++++++++-------
 .../Vector128_1/GetAndWithElement.Int16.3.cs  | 26 ++++++++-------
 .../Vector128_1/GetAndWithElement.Int16.7.cs  | 26 ++++++++-------
 .../Vector128_1/GetAndWithElement.Int32.0.cs  | 26 ++++++++-------
 .../Vector128_1/GetAndWithElement.Int32.1.cs  | 26 ++++++++-------
 .../Vector128_1/GetAndWithElement.Int32.3.cs  | 26 ++++++++-------
 .../Vector128_1/GetAndWithElement.Int64.0.cs  | 26 ++++++++-------
 .../Vector128_1/GetAndWithElement.Int64.1.cs  | 26 ++++++++-------
 .../Vector128_1/GetAndWithElement.SByte.0.cs  | 26 ++++++++-------
 .../Vector128_1/GetAndWithElement.SByte.15.cs | 26 ++++++++-------
 .../Vector128_1/GetAndWithElement.SByte.7.cs  | 26 ++++++++-------
 .../Vector128_1/GetAndWithElement.Single.0.cs | 26 ++++++++-------
 .../Vector128_1/GetAndWithElement.Single.1.cs | 26 ++++++++-------
 .../Vector128_1/GetAndWithElement.Single.3.cs | 26 ++++++++-------
 .../Vector128_1/GetAndWithElement.UInt16.0.cs | 26 ++++++++-------
 .../Vector128_1/GetAndWithElement.UInt16.3.cs | 26 ++++++++-------
 .../Vector128_1/GetAndWithElement.UInt16.7.cs | 26 ++++++++-------
 .../Vector128_1/GetAndWithElement.UInt32.0.cs | 26 ++++++++-------
 .../Vector128_1/GetAndWithElement.UInt32.1.cs | 26 ++++++++-------
 .../Vector128_1/GetAndWithElement.UInt32.3.cs | 26 ++++++++-------
 .../Vector128_1/GetAndWithElement.UInt64.0.cs | 26 ++++++++-------
 .../Vector128_1/GetAndWithElement.UInt64.1.cs | 26 ++++++++-------
 .../GetAndWithLowerAndUpper.Byte.cs           | 32 ++++++++++++++-----
 .../GetAndWithLowerAndUpper.Double.cs         | 32 ++++++++++++++-----
 .../GetAndWithLowerAndUpper.Int16.cs          | 32 ++++++++++++++-----
 .../GetAndWithLowerAndUpper.Int32.cs          | 32 ++++++++++++++-----
 .../GetAndWithLowerAndUpper.Int64.cs          | 32 ++++++++++++++-----
 .../GetAndWithLowerAndUpper.SByte.cs          | 32 ++++++++++++++-----
 .../GetAndWithLowerAndUpper.Single.cs         | 32 ++++++++++++++-----
 .../GetAndWithLowerAndUpper.UInt16.cs         | 32 ++++++++++++++-----
 .../GetAndWithLowerAndUpper.UInt32.cs         | 32 ++++++++++++++-----
 .../GetAndWithLowerAndUpper.UInt64.cs         | 32 ++++++++++++++-----
 .../General/Vector128_1/ToScalar.Byte.cs      |  4 +--
 .../General/Vector128_1/ToScalar.Double.cs    |  4 +--
 .../General/Vector128_1/ToScalar.Int16.cs     |  4 +--
 .../General/Vector128_1/ToScalar.Int32.cs     |  4 +--
 .../General/Vector128_1/ToScalar.Int64.cs     |  4 +--
 .../General/Vector128_1/ToScalar.SByte.cs     |  4 +--
 .../General/Vector128_1/ToScalar.Single.cs    |  4 +--
 .../General/Vector128_1/ToScalar.UInt16.cs    |  4 +--
 .../General/Vector128_1/ToScalar.UInt32.cs    |  4 +--
 .../General/Vector128_1/ToScalar.UInt64.cs    |  4 +--
 .../General/Vector128_1/ToVector256.Byte.cs   | 10 ++++--
 .../General/Vector128_1/ToVector256.Double.cs | 10 ++++--
 .../General/Vector128_1/ToVector256.Int16.cs  | 10 ++++--
 .../General/Vector128_1/ToVector256.Int32.cs  | 10 ++++--
 .../General/Vector128_1/ToVector256.Int64.cs  | 10 ++++--
 .../General/Vector128_1/ToVector256.SByte.cs  | 10 ++++--
 .../General/Vector128_1/ToVector256.Single.cs | 10 ++++--
 .../General/Vector128_1/ToVector256.UInt16.cs | 10 ++++--
 .../General/Vector128_1/ToVector256.UInt32.cs | 10 ++++--
 .../General/Vector128_1/ToVector256.UInt64.cs | 10 ++++--
 .../General/Vector128_1/Zero.Byte.cs          |  8 +++--
 .../General/Vector128_1/Zero.Double.cs        |  8 +++--
 .../General/Vector128_1/Zero.Int16.cs         |  8 +++--
 .../General/Vector128_1/Zero.Int32.cs         |  8 +++--
 .../General/Vector128_1/Zero.Int64.cs         |  8 +++--
 .../General/Vector128_1/Zero.SByte.cs         |  8 +++--
 .../General/Vector128_1/Zero.Single.cs        |  8 +++--
 .../General/Vector128_1/Zero.UInt16.cs        |  8 +++--
 .../General/Vector128_1/Zero.UInt32.cs        |  8 +++--
 .../General/Vector128_1/Zero.UInt64.cs        |  8 +++--
 .../General/Vector256/Create.Byte.cs          | 10 ++++--
 .../General/Vector256/Create.Double.cs        | 10 ++++--
 .../General/Vector256/Create.Int16.cs         | 10 ++++--
 .../General/Vector256/Create.Int32.cs         | 10 ++++--
 .../General/Vector256/Create.Int64.cs         | 10 ++++--
 .../General/Vector256/Create.SByte.cs         | 10 ++++--
 .../General/Vector256/Create.Single.cs        | 10 ++++--
 .../General/Vector256/Create.UInt16.cs        | 10 ++++--
 .../General/Vector256/Create.UInt32.cs        | 10 ++++--
 .../General/Vector256/Create.UInt64.cs        | 10 ++++--
 .../General/Vector256/CreateElement.Byte.cs   |  8 +++--
 .../General/Vector256/CreateElement.Double.cs |  8 +++--
 .../General/Vector256/CreateElement.Int16.cs  |  8 +++--
 .../General/Vector256/CreateElement.Int32.cs  |  8 +++--
 .../General/Vector256/CreateElement.Int64.cs  |  8 +++--
 .../General/Vector256/CreateElement.SByte.cs  |  8 +++--
 .../General/Vector256/CreateElement.Single.cs |  8 +++--
 .../General/Vector256/CreateElement.UInt16.cs |  8 +++--
 .../General/Vector256/CreateElement.UInt32.cs |  8 +++--
 .../General/Vector256/CreateElement.UInt64.cs |  8 +++--
 .../General/Vector256/CreateScalar.Byte.cs    | 10 ++++--
 .../General/Vector256/CreateScalar.Double.cs  | 10 ++++--
 .../General/Vector256/CreateScalar.Int16.cs   | 10 ++++--
 .../General/Vector256/CreateScalar.Int32.cs   | 10 ++++--
 .../General/Vector256/CreateScalar.Int64.cs   | 10 ++++--
 .../General/Vector256/CreateScalar.SByte.cs   | 10 ++++--
 .../General/Vector256/CreateScalar.Single.cs  | 10 ++++--
 .../General/Vector256/CreateScalar.UInt16.cs  | 10 ++++--
 .../General/Vector256/CreateScalar.UInt32.cs  | 10 ++++--
 .../General/Vector256/CreateScalar.UInt64.cs  | 10 ++++--
 .../Vector256/CreateScalarUnsafe.Byte.cs      | 10 ++++--
 .../Vector256/CreateScalarUnsafe.Double.cs    | 10 ++++--
 .../Vector256/CreateScalarUnsafe.Int16.cs     | 10 ++++--
 .../Vector256/CreateScalarUnsafe.Int32.cs     | 10 ++++--
 .../Vector256/CreateScalarUnsafe.Int64.cs     | 10 ++++--
 .../Vector256/CreateScalarUnsafe.SByte.cs     | 10 ++++--
 .../Vector256/CreateScalarUnsafe.Single.cs    | 10 ++++--
 .../Vector256/CreateScalarUnsafe.UInt16.cs    | 10 ++++--
 .../Vector256/CreateScalarUnsafe.UInt32.cs    | 10 ++++--
 .../Vector256/CreateScalarUnsafe.UInt64.cs    | 10 ++++--
 .../General/Vector256/CreateVector.Byte.cs    | 10 ++++--
 .../General/Vector256/CreateVector.Double.cs  | 10 ++++--
 .../General/Vector256/CreateVector.Int16.cs   | 10 ++++--
 .../General/Vector256/CreateVector.Int32.cs   | 10 ++++--
 .../General/Vector256/CreateVector.Int64.cs   | 10 ++++--
 .../General/Vector256/CreateVector.SByte.cs   | 10 ++++--
 .../General/Vector256/CreateVector.Single.cs  | 10 ++++--
 .../General/Vector256/CreateVector.UInt16.cs  | 10 ++++--
 .../General/Vector256/CreateVector.UInt32.cs  | 10 ++++--
 .../General/Vector256/CreateVector.UInt64.cs  | 10 ++++--
 .../General/Vector256_1/As.Byte.cs            |  8 +++--
 .../General/Vector256_1/As.Double.cs          |  8 +++--
 .../General/Vector256_1/As.Int16.cs           |  8 +++--
 .../General/Vector256_1/As.Int32.cs           |  8 +++--
 .../General/Vector256_1/As.Int64.cs           |  8 +++--
 .../General/Vector256_1/As.SByte.cs           |  8 +++--
 .../General/Vector256_1/As.Single.cs          |  8 +++--
 .../General/Vector256_1/As.UInt16.cs          |  8 +++--
 .../General/Vector256_1/As.UInt32.cs          |  8 +++--
 .../General/Vector256_1/As.UInt64.cs          |  8 +++--
 .../Vector256_1/GetAndWithElement.Byte.0.cs   | 26 ++++++++-------
 .../Vector256_1/GetAndWithElement.Byte.15.cs  | 26 ++++++++-------
 .../Vector256_1/GetAndWithElement.Byte.31.cs  | 26 ++++++++-------
 .../Vector256_1/GetAndWithElement.Byte.7.cs   | 26 ++++++++-------
 .../Vector256_1/GetAndWithElement.Double.0.cs | 26 ++++++++-------
 .../Vector256_1/GetAndWithElement.Double.1.cs | 26 ++++++++-------
 .../Vector256_1/GetAndWithElement.Double.3.cs | 26 ++++++++-------
 .../Vector256_1/GetAndWithElement.Int16.0.cs  | 26 ++++++++-------
 .../Vector256_1/GetAndWithElement.Int16.15.cs | 26 ++++++++-------
 .../Vector256_1/GetAndWithElement.Int16.3.cs  | 26 ++++++++-------
 .../Vector256_1/GetAndWithElement.Int16.7.cs  | 26 ++++++++-------
 .../Vector256_1/GetAndWithElement.Int32.0.cs  | 26 ++++++++-------
 .../Vector256_1/GetAndWithElement.Int32.1.cs  | 26 ++++++++-------
 .../Vector256_1/GetAndWithElement.Int32.3.cs  | 26 ++++++++-------
 .../Vector256_1/GetAndWithElement.Int32.7.cs  | 26 ++++++++-------
 .../Vector256_1/GetAndWithElement.Int64.0.cs  | 26 ++++++++-------
 .../Vector256_1/GetAndWithElement.Int64.1.cs  | 26 ++++++++-------
 .../Vector256_1/GetAndWithElement.Int64.3.cs  | 26 ++++++++-------
 .../Vector256_1/GetAndWithElement.SByte.0.cs  | 26 ++++++++-------
 .../Vector256_1/GetAndWithElement.SByte.15.cs | 26 ++++++++-------
 .../Vector256_1/GetAndWithElement.SByte.31.cs | 26 ++++++++-------
 .../Vector256_1/GetAndWithElement.SByte.7.cs  | 26 ++++++++-------
 .../Vector256_1/GetAndWithElement.Single.0.cs | 26 ++++++++-------
 .../Vector256_1/GetAndWithElement.Single.1.cs | 26 ++++++++-------
 .../Vector256_1/GetAndWithElement.Single.3.cs | 26 ++++++++-------
 .../Vector256_1/GetAndWithElement.Single.7.cs | 26 ++++++++-------
 .../Vector256_1/GetAndWithElement.UInt16.0.cs | 26 ++++++++-------
 .../GetAndWithElement.UInt16.15.cs            | 26 ++++++++-------
 .../Vector256_1/GetAndWithElement.UInt16.3.cs | 26 ++++++++-------
 .../Vector256_1/GetAndWithElement.UInt16.7.cs | 26 ++++++++-------
 .../Vector256_1/GetAndWithElement.UInt32.0.cs | 26 ++++++++-------
 .../Vector256_1/GetAndWithElement.UInt32.1.cs | 26 ++++++++-------
 .../Vector256_1/GetAndWithElement.UInt32.3.cs | 26 ++++++++-------
 .../Vector256_1/GetAndWithElement.UInt32.7.cs | 26 ++++++++-------
 .../Vector256_1/GetAndWithElement.UInt64.0.cs | 26 ++++++++-------
 .../Vector256_1/GetAndWithElement.UInt64.1.cs | 26 ++++++++-------
 .../Vector256_1/GetAndWithElement.UInt64.3.cs | 26 ++++++++-------
 .../GetAndWithLowerAndUpper.Byte.cs           | 32 ++++++++++++++-----
 .../GetAndWithLowerAndUpper.Double.cs         | 32 ++++++++++++++-----
 .../GetAndWithLowerAndUpper.Int16.cs          | 32 ++++++++++++++-----
 .../GetAndWithLowerAndUpper.Int32.cs          | 32 ++++++++++++++-----
 .../GetAndWithLowerAndUpper.Int64.cs          | 32 ++++++++++++++-----
 .../GetAndWithLowerAndUpper.SByte.cs          | 32 ++++++++++++++-----
 .../GetAndWithLowerAndUpper.Single.cs         | 32 ++++++++++++++-----
 .../GetAndWithLowerAndUpper.UInt16.cs         | 32 ++++++++++++++-----
 .../GetAndWithLowerAndUpper.UInt32.cs         | 32 ++++++++++++++-----
 .../GetAndWithLowerAndUpper.UInt64.cs         | 32 ++++++++++++++-----
 .../General/Vector256_1/ToScalar.Byte.cs      |  4 +--
 .../General/Vector256_1/ToScalar.Double.cs    |  4 +--
 .../General/Vector256_1/ToScalar.Int16.cs     |  4 +--
 .../General/Vector256_1/ToScalar.Int32.cs     |  4 +--
 .../General/Vector256_1/ToScalar.Int64.cs     |  4 +--
 .../General/Vector256_1/ToScalar.SByte.cs     |  4 +--
 .../General/Vector256_1/ToScalar.Single.cs    |  4 +--
 .../General/Vector256_1/ToScalar.UInt16.cs    |  4 +--
 .../General/Vector256_1/ToScalar.UInt32.cs    |  4 +--
 .../General/Vector256_1/ToScalar.UInt64.cs    |  4 +--
 .../General/Vector256_1/Zero.Byte.cs          |  8 +++--
 .../General/Vector256_1/Zero.Double.cs        |  8 +++--
 .../General/Vector256_1/Zero.Int16.cs         |  8 +++--
 .../General/Vector256_1/Zero.Int32.cs         |  8 +++--
 .../General/Vector256_1/Zero.Int64.cs         |  8 +++--
 .../General/Vector256_1/Zero.SByte.cs         |  8 +++--
 .../General/Vector256_1/Zero.Single.cs        |  8 +++--
 .../General/Vector256_1/Zero.UInt16.cs        |  8 +++--
 .../General/Vector256_1/Zero.UInt32.cs        |  8 +++--
 .../General/Vector256_1/Zero.UInt64.cs        |  8 +++--
 .../General/Vector64/Create.Byte.cs           | 10 ++++--
 .../General/Vector64/Create.Double.cs         | 10 ++++--
 .../General/Vector64/Create.Int16.cs          | 10 ++++--
 .../General/Vector64/Create.Int32.cs          | 10 ++++--
 .../General/Vector64/Create.Int64.cs          | 10 ++++--
 .../General/Vector64/Create.SByte.cs          | 10 ++++--
 .../General/Vector64/Create.Single.cs         | 10 ++++--
 .../General/Vector64/Create.UInt16.cs         | 10 ++++--
 .../General/Vector64/Create.UInt32.cs         | 10 ++++--
 .../General/Vector64/Create.UInt64.cs         | 10 ++++--
 .../General/Vector64/CreateElement.Byte.cs    |  8 +++--
 .../General/Vector64/CreateElement.Int16.cs   |  8 +++--
 .../General/Vector64/CreateElement.Int32.cs   |  8 +++--
 .../General/Vector64/CreateElement.SByte.cs   |  8 +++--
 .../General/Vector64/CreateElement.Single.cs  |  8 +++--
 .../General/Vector64/CreateElement.UInt16.cs  |  8 +++--
 .../General/Vector64/CreateElement.UInt32.cs  |  8 +++--
 .../General/Vector64/CreateScalar.Byte.cs     | 10 ++++--
 .../General/Vector64/CreateScalar.Int16.cs    | 10 ++++--
 .../General/Vector64/CreateScalar.Int32.cs    | 10 ++++--
 .../General/Vector64/CreateScalar.SByte.cs    | 10 ++++--
 .../General/Vector64/CreateScalar.Single.cs   | 10 ++++--
 .../General/Vector64/CreateScalar.UInt16.cs   | 10 ++++--
 .../General/Vector64/CreateScalar.UInt32.cs   | 10 ++++--
 .../Vector64/CreateScalarUnsafe.Byte.cs       | 10 ++++--
 .../Vector64/CreateScalarUnsafe.Int16.cs      | 10 ++++--
 .../Vector64/CreateScalarUnsafe.Int32.cs      | 10 ++++--
 .../Vector64/CreateScalarUnsafe.SByte.cs      | 10 ++++--
 .../Vector64/CreateScalarUnsafe.Single.cs     | 10 ++++--
 .../Vector64/CreateScalarUnsafe.UInt16.cs     | 10 ++++--
 .../Vector64/CreateScalarUnsafe.UInt32.cs     | 10 ++++--
 .../General/Vector64_1/As.Byte.cs             |  8 +++--
 .../General/Vector64_1/As.Double.cs           |  8 +++--
 .../General/Vector64_1/As.Int16.cs            |  8 +++--
 .../General/Vector64_1/As.Int32.cs            |  8 +++--
 .../General/Vector64_1/As.Int64.cs            |  8 +++--
 .../General/Vector64_1/As.SByte.cs            |  8 +++--
 .../General/Vector64_1/As.Single.cs           |  8 +++--
 .../General/Vector64_1/As.UInt16.cs           |  8 +++--
 .../General/Vector64_1/As.UInt32.cs           |  8 +++--
 .../General/Vector64_1/As.UInt64.cs           |  8 +++--
 .../Vector64_1/GetAndWithElement.Byte.0.cs    | 26 ++++++++-------
 .../Vector64_1/GetAndWithElement.Byte.7.cs    | 26 ++++++++-------
 .../Vector64_1/GetAndWithElement.Double.0.cs  | 26 ++++++++-------
 .../Vector64_1/GetAndWithElement.Int16.0.cs   | 26 ++++++++-------
 .../Vector64_1/GetAndWithElement.Int16.3.cs   | 26 ++++++++-------
 .../Vector64_1/GetAndWithElement.Int32.0.cs   | 26 ++++++++-------
 .../Vector64_1/GetAndWithElement.Int32.1.cs   | 26 ++++++++-------
 .../Vector64_1/GetAndWithElement.Int64.0.cs   | 26 ++++++++-------
 .../Vector64_1/GetAndWithElement.SByte.0.cs   | 26 ++++++++-------
 .../Vector64_1/GetAndWithElement.SByte.7.cs   | 26 ++++++++-------
 .../Vector64_1/GetAndWithElement.Single.0.cs  | 26 ++++++++-------
 .../Vector64_1/GetAndWithElement.Single.1.cs  | 26 ++++++++-------
 .../Vector64_1/GetAndWithElement.UInt16.0.cs  | 26 ++++++++-------
 .../Vector64_1/GetAndWithElement.UInt16.3.cs  | 26 ++++++++-------
 .../Vector64_1/GetAndWithElement.UInt32.0.cs  | 26 ++++++++-------
 .../Vector64_1/GetAndWithElement.UInt32.1.cs  | 26 ++++++++-------
 .../Vector64_1/GetAndWithElement.UInt64.0.cs  | 26 ++++++++-------
 .../General/Vector64_1/ToScalar.Byte.cs       |  4 +--
 .../General/Vector64_1/ToScalar.Double.cs     |  4 +--
 .../General/Vector64_1/ToScalar.Int16.cs      |  4 +--
 .../General/Vector64_1/ToScalar.Int32.cs      |  4 +--
 .../General/Vector64_1/ToScalar.Int64.cs      |  4 +--
 .../General/Vector64_1/ToScalar.SByte.cs      |  4 +--
 .../General/Vector64_1/ToScalar.Single.cs     |  4 +--
 .../General/Vector64_1/ToScalar.UInt16.cs     |  4 +--
 .../General/Vector64_1/ToScalar.UInt32.cs     |  4 +--
 .../General/Vector64_1/ToScalar.UInt64.cs     |  4 +--
 .../General/Vector64_1/ToVector128.Byte.cs    | 10 ++++--
 .../General/Vector64_1/ToVector128.Double.cs  | 10 ++++--
 .../General/Vector64_1/ToVector128.Int16.cs   | 10 ++++--
 .../General/Vector64_1/ToVector128.Int32.cs   | 10 ++++--
 .../General/Vector64_1/ToVector128.Int64.cs   | 10 ++++--
 .../General/Vector64_1/ToVector128.SByte.cs   | 10 ++++--
 .../General/Vector64_1/ToVector128.Single.cs  | 10 ++++--
 .../General/Vector64_1/ToVector128.UInt16.cs  | 10 ++++--
 .../General/Vector64_1/ToVector128.UInt32.cs  | 10 ++++--
 .../General/Vector64_1/ToVector128.UInt64.cs  | 10 ++++--
 .../General/Vector64_1/Zero.Byte.cs           |  8 +++--
 .../General/Vector64_1/Zero.Double.cs         |  8 +++--
 .../General/Vector64_1/Zero.Int16.cs          |  8 +++--
 .../General/Vector64_1/Zero.Int32.cs          |  8 +++--
 .../General/Vector64_1/Zero.Int64.cs          |  8 +++--
 .../General/Vector64_1/Zero.SByte.cs          |  8 +++--
 .../General/Vector64_1/Zero.Single.cs         |  8 +++--
 .../General/Vector64_1/Zero.UInt16.cs         |  8 +++--
 .../General/Vector64_1/Zero.UInt32.cs         |  8 +++--
 .../General/Vector64_1/Zero.UInt64.cs         |  8 +++--
 .../X86/Aes/Decrypt.Byte.cs                   | 18 ++++++++---
 .../X86/Aes/DecryptLast.Byte.cs               | 18 ++++++++---
 .../X86/Aes/Encrypt.Byte.cs                   | 18 ++++++++---
 .../X86/Aes/EncryptLast.Byte.cs               | 18 ++++++++---
 .../X86/Aes/InverseMixColumns.Byte.cs         | 19 ++++++++---
 .../X86/Aes/KeygenAssist.Byte.5.cs            | 23 +++++++++----
 .../HardwareIntrinsics/X86/Avx/Add.Double.cs  | 19 ++++++++---
 .../HardwareIntrinsics/X86/Avx/Add.Single.cs  | 19 ++++++++---
 .../X86/Avx/AddSubtract.Double.cs             | 19 ++++++++---
 .../X86/Avx/AddSubtract.Single.cs             | 19 ++++++++---
 .../HardwareIntrinsics/X86/Avx/And.Double.cs  | 19 ++++++++---
 .../HardwareIntrinsics/X86/Avx/And.Single.cs  | 19 ++++++++---
 .../X86/Avx/AndNot.Double.cs                  | 19 ++++++++---
 .../X86/Avx/AndNot.Single.cs                  | 19 ++++++++---
 .../X86/Avx/BlendVariable.Double.cs           | 19 ++++++++---
 .../X86/Avx/BlendVariable.Single.cs           | 19 ++++++++---
 .../Avx/BroadcastScalarToVector128.Single.cs  | 10 ++++--
 .../Avx/BroadcastScalarToVector256.Double.cs  | 10 ++++--
 .../Avx/BroadcastScalarToVector256.Single.cs  | 10 ++++--
 .../BroadcastVector128ToVector256.Double.cs   | 10 ++++--
 .../BroadcastVector128ToVector256.Single.cs   | 10 ++++--
 .../X86/Avx/Ceiling.Double.cs                 | 19 ++++++++---
 .../X86/Avx/Ceiling.Single.cs                 | 19 ++++++++---
 .../X86/Avx/Divide.Double.cs                  | 19 ++++++++---
 .../X86/Avx/Divide.Single.cs                  | 19 ++++++++---
 .../X86/Avx/DuplicateEvenIndexed.Double.cs    | 19 ++++++++---
 .../X86/Avx/DuplicateEvenIndexed.Single.cs    | 19 ++++++++---
 .../X86/Avx/DuplicateOddIndexed.Single.cs     | 19 ++++++++---
 .../X86/Avx/ExtractVector128.Byte.1.Store.cs  | 19 ++++++++---
 .../X86/Avx/ExtractVector128.Byte.1.cs        | 19 ++++++++---
 .../Avx/ExtractVector128.Double.1.Store.cs    | 19 ++++++++---
 .../X86/Avx/ExtractVector128.Double.1.cs      | 19 ++++++++---
 .../X86/Avx/ExtractVector128.Int16.1.Store.cs | 19 ++++++++---
 .../X86/Avx/ExtractVector128.Int16.1.cs       | 19 ++++++++---
 .../X86/Avx/ExtractVector128.Int32.1.Store.cs | 19 ++++++++---
 .../X86/Avx/ExtractVector128.Int32.1.cs       | 19 ++++++++---
 .../X86/Avx/ExtractVector128.Int64.1.Store.cs | 19 ++++++++---
 .../X86/Avx/ExtractVector128.Int64.1.cs       | 19 ++++++++---
 .../X86/Avx/ExtractVector128.SByte.1.Store.cs | 19 ++++++++---
 .../X86/Avx/ExtractVector128.SByte.1.cs       | 19 ++++++++---
 .../Avx/ExtractVector128.Single.1.Store.cs    | 19 ++++++++---
 .../X86/Avx/ExtractVector128.Single.1.cs      | 19 ++++++++---
 .../Avx/ExtractVector128.UInt16.1.Store.cs    | 19 ++++++++---
 .../X86/Avx/ExtractVector128.UInt16.1.cs      | 19 ++++++++---
 .../Avx/ExtractVector128.UInt32.1.Store.cs    | 19 ++++++++---
 .../X86/Avx/ExtractVector128.UInt32.1.cs      | 19 ++++++++---
 .../Avx/ExtractVector128.UInt64.1.Store.cs    | 19 ++++++++---
 .../X86/Avx/ExtractVector128.UInt64.1.cs      | 19 ++++++++---
 .../X86/Avx/Floor.Double.cs                   | 19 ++++++++---
 .../X86/Avx/Floor.Single.cs                   | 19 ++++++++---
 .../X86/Avx/InsertVector128.Byte.1.Load.cs    | 19 ++++++++---
 .../X86/Avx/InsertVector128.Byte.1.cs         | 19 ++++++++---
 .../X86/Avx/InsertVector128.Double.1.Load.cs  | 19 ++++++++---
 .../X86/Avx/InsertVector128.Double.1.cs       | 19 ++++++++---
 .../X86/Avx/InsertVector128.Int16.1.Load.cs   | 19 ++++++++---
 .../X86/Avx/InsertVector128.Int16.1.cs        | 19 ++++++++---
 .../X86/Avx/InsertVector128.Int32.1.Load.cs   | 19 ++++++++---
 .../X86/Avx/InsertVector128.Int32.1.cs        | 19 ++++++++---
 .../X86/Avx/InsertVector128.Int64.1.Load.cs   | 19 ++++++++---
 .../X86/Avx/InsertVector128.Int64.1.cs        | 19 ++++++++---
 .../X86/Avx/InsertVector128.SByte.1.Load.cs   | 19 ++++++++---
 .../X86/Avx/InsertVector128.SByte.1.cs        | 19 ++++++++---
 .../X86/Avx/InsertVector128.Single.1.Load.cs  | 19 ++++++++---
 .../X86/Avx/InsertVector128.Single.1.cs       | 19 ++++++++---
 .../X86/Avx/InsertVector128.UInt16.1.Load.cs  | 19 ++++++++---
 .../X86/Avx/InsertVector128.UInt16.1.cs       | 19 ++++++++---
 .../X86/Avx/InsertVector128.UInt32.1.Load.cs  | 19 ++++++++---
 .../X86/Avx/InsertVector128.UInt32.1.cs       | 19 ++++++++---
 .../X86/Avx/InsertVector128.UInt64.1.Load.cs  | 19 ++++++++---
 .../X86/Avx/InsertVector128.UInt64.1.cs       | 19 ++++++++---
 .../X86/Avx/LoadVector256.Byte.cs             | 10 ++++--
 .../X86/Avx/LoadVector256.Double.cs           | 10 ++++--
 .../X86/Avx/LoadVector256.Int16.cs            | 10 ++++--
 .../X86/Avx/LoadVector256.Int32.cs            | 10 ++++--
 .../X86/Avx/LoadVector256.Int64.cs            | 10 ++++--
 .../X86/Avx/LoadVector256.SByte.cs            | 10 ++++--
 .../X86/Avx/LoadVector256.Single.cs           | 10 ++++--
 .../X86/Avx/LoadVector256.UInt16.cs           | 10 ++++--
 .../X86/Avx/LoadVector256.UInt32.cs           | 10 ++++--
 .../X86/Avx/LoadVector256.UInt64.cs           | 10 ++++--
 .../X86/Avx/MaskLoad.Double.cs                | 19 ++++++++---
 .../X86/Avx/MaskLoad.Single.cs                | 19 ++++++++---
 .../X86/Avx/MaskStore.Double.cs               | 19 ++++++++---
 .../X86/Avx/MaskStore.Single.cs               | 19 ++++++++---
 .../HardwareIntrinsics/X86/Avx/Max.Double.cs  | 19 ++++++++---
 .../HardwareIntrinsics/X86/Avx/Max.Single.cs  | 19 ++++++++---
 .../HardwareIntrinsics/X86/Avx/Min.Double.cs  | 19 ++++++++---
 .../HardwareIntrinsics/X86/Avx/Min.Single.cs  | 19 ++++++++---
 .../X86/Avx/Multiply.Double.cs                | 19 ++++++++---
 .../X86/Avx/Multiply.Single.cs                | 19 ++++++++---
 .../HardwareIntrinsics/X86/Avx/Or.Double.cs   | 19 ++++++++---
 .../HardwareIntrinsics/X86/Avx/Or.Single.cs   | 19 ++++++++---
 .../X86/Avx/Permute.Double.1.cs               | 19 ++++++++---
 .../X86/Avx/Permute.Double.2.cs               | 19 ++++++++---
 .../X86/Avx/Permute.Single.1.cs               | 19 ++++++++---
 .../X86/Avx/Permute.Single.2.cs               | 19 ++++++++---
 .../X86/Avx/Permute2x128.Byte.2.cs            | 19 ++++++++---
 .../X86/Avx/Permute2x128.Double.2.cs          | 19 ++++++++---
 .../X86/Avx/Permute2x128.Int16.2.cs           | 19 ++++++++---
 .../X86/Avx/Permute2x128.Int32.2.cs           | 19 ++++++++---
 .../X86/Avx/Permute2x128.Int64.2.cs           | 19 ++++++++---
 .../X86/Avx/Permute2x128.SByte.2.cs           | 19 ++++++++---
 .../X86/Avx/Permute2x128.Single.2.cs          | 19 ++++++++---
 .../X86/Avx/Permute2x128.UInt16.2.cs          | 19 ++++++++---
 .../X86/Avx/Permute2x128.UInt32.2.cs          | 19 ++++++++---
 .../X86/Avx/Permute2x128.UInt64.2.cs          | 19 ++++++++---
 .../X86/Avx/RoundCurrentDirection.Double.cs   | 19 ++++++++---
 .../X86/Avx/RoundCurrentDirection.Single.cs   | 19 ++++++++---
 .../X86/Avx/RoundToNearestInteger.Double.cs   | 19 ++++++++---
 .../X86/Avx/RoundToNearestInteger.Single.cs   | 19 ++++++++---
 .../X86/Avx/RoundToNegativeInfinity.Double.cs | 19 ++++++++---
 .../X86/Avx/RoundToNegativeInfinity.Single.cs | 19 ++++++++---
 .../X86/Avx/RoundToPositiveInfinity.Double.cs | 19 ++++++++---
 .../X86/Avx/RoundToPositiveInfinity.Single.cs | 19 ++++++++---
 .../X86/Avx/RoundToZero.Double.cs             | 19 ++++++++---
 .../X86/Avx/RoundToZero.Single.cs             | 19 ++++++++---
 .../X86/Avx/Shuffle.Double.1.cs               | 19 ++++++++---
 .../X86/Avx/Shuffle.Single.1.cs               | 19 ++++++++---
 .../X86/Avx/Subtract.Double.cs                | 19 ++++++++---
 .../X86/Avx/Subtract.Single.cs                | 19 ++++++++---
 .../HardwareIntrinsics/X86/Avx/TestC.Byte.cs  | 13 +++++---
 .../HardwareIntrinsics/X86/Avx/TestC.Int16.cs | 13 +++++---
 .../HardwareIntrinsics/X86/Avx/TestC.Int32.cs | 13 +++++---
 .../HardwareIntrinsics/X86/Avx/TestC.Int64.cs | 13 +++++---
 .../HardwareIntrinsics/X86/Avx/TestC.SByte.cs | 13 +++++---
 .../X86/Avx/TestC.UInt16.cs                   | 13 +++++---
 .../X86/Avx/TestC.UInt32.cs                   | 13 +++++---
 .../X86/Avx/TestC.UInt64.cs                   | 13 +++++---
 .../X86/Avx/TestNotZAndNotC.Byte.cs           | 13 +++++---
 .../X86/Avx/TestNotZAndNotC.Int16.cs          | 13 +++++---
 .../X86/Avx/TestNotZAndNotC.Int32.cs          | 13 +++++---
 .../X86/Avx/TestNotZAndNotC.Int64.cs          | 13 +++++---
 .../X86/Avx/TestNotZAndNotC.SByte.cs          | 13 +++++---
 .../X86/Avx/TestNotZAndNotC.UInt16.cs         | 13 +++++---
 .../X86/Avx/TestNotZAndNotC.UInt32.cs         | 13 +++++---
 .../X86/Avx/TestNotZAndNotC.UInt64.cs         | 13 +++++---
 .../HardwareIntrinsics/X86/Avx/TestZ.Byte.cs  | 13 +++++---
 .../HardwareIntrinsics/X86/Avx/TestZ.Int16.cs | 13 +++++---
 .../HardwareIntrinsics/X86/Avx/TestZ.Int32.cs | 13 +++++---
 .../HardwareIntrinsics/X86/Avx/TestZ.Int64.cs | 13 +++++---
 .../HardwareIntrinsics/X86/Avx/TestZ.SByte.cs | 13 +++++---
 .../X86/Avx/TestZ.UInt16.cs                   | 13 +++++---
 .../X86/Avx/TestZ.UInt32.cs                   | 13 +++++---
 .../X86/Avx/TestZ.UInt64.cs                   | 13 +++++---
 .../HardwareIntrinsics/X86/Avx/Xor.Double.cs  | 19 ++++++++---
 .../HardwareIntrinsics/X86/Avx/Xor.Single.cs  | 19 ++++++++---
 .../HardwareIntrinsics/X86/Avx2/Add.Byte.cs   | 19 ++++++++---
 .../HardwareIntrinsics/X86/Avx2/Add.Int16.cs  | 19 ++++++++---
 .../HardwareIntrinsics/X86/Avx2/Add.Int32.cs  | 19 ++++++++---
 .../HardwareIntrinsics/X86/Avx2/Add.Int64.cs  | 19 ++++++++---
 .../HardwareIntrinsics/X86/Avx2/Add.SByte.cs  | 19 ++++++++---
 .../HardwareIntrinsics/X86/Avx2/Add.UInt16.cs | 19 ++++++++---
 .../HardwareIntrinsics/X86/Avx2/Add.UInt32.cs | 19 ++++++++---
 .../HardwareIntrinsics/X86/Avx2/Add.UInt64.cs | 19 ++++++++---
 .../X86/Avx2/AlignRight.Byte.228.cs           | 19 ++++++++---
 .../X86/Avx2/AlignRight.Byte.250.cs           | 19 ++++++++---
 .../X86/Avx2/AlignRight.Byte.27.cs            | 19 ++++++++---
 .../X86/Avx2/AlignRight.Byte.5.cs             | 19 ++++++++---
 .../X86/Avx2/AlignRight.Int16.0.cs            | 19 ++++++++---
 .../X86/Avx2/AlignRight.Int16.2.cs            | 19 ++++++++---
 .../X86/Avx2/AlignRight.Int32.0.cs            | 19 ++++++++---
 .../X86/Avx2/AlignRight.Int32.4.cs            | 19 ++++++++---
 .../X86/Avx2/AlignRight.Int64.0.cs            | 19 ++++++++---
 .../X86/Avx2/AlignRight.Int64.8.cs            | 19 ++++++++---
 .../X86/Avx2/AlignRight.SByte.228.cs          | 19 ++++++++---
 .../X86/Avx2/AlignRight.SByte.250.cs          | 19 ++++++++---
 .../X86/Avx2/AlignRight.SByte.27.cs           | 19 ++++++++---
 .../X86/Avx2/AlignRight.SByte.5.cs            | 19 ++++++++---
 .../X86/Avx2/AlignRight.UInt16.0.cs           | 19 ++++++++---
 .../X86/Avx2/AlignRight.UInt16.2.cs           | 19 ++++++++---
 .../X86/Avx2/AlignRight.UInt32.0.cs           | 19 ++++++++---
 .../X86/Avx2/AlignRight.UInt32.4.cs           | 19 ++++++++---
 .../X86/Avx2/AlignRight.UInt64.0.cs           | 19 ++++++++---
 .../X86/Avx2/AlignRight.UInt64.8.cs           | 19 ++++++++---
 .../HardwareIntrinsics/X86/Avx2/And.Byte.cs   | 19 ++++++++---
 .../HardwareIntrinsics/X86/Avx2/And.Int16.cs  | 19 ++++++++---
 .../HardwareIntrinsics/X86/Avx2/And.Int32.cs  | 19 ++++++++---
 .../HardwareIntrinsics/X86/Avx2/And.Int64.cs  | 19 ++++++++---
 .../HardwareIntrinsics/X86/Avx2/And.SByte.cs  | 19 ++++++++---
 .../HardwareIntrinsics/X86/Avx2/And.UInt16.cs | 19 ++++++++---
 .../HardwareIntrinsics/X86/Avx2/And.UInt32.cs | 19 ++++++++---
 .../HardwareIntrinsics/X86/Avx2/And.UInt64.cs | 19 ++++++++---
 .../X86/Avx2/AndNot.Byte.cs                   | 19 ++++++++---
 .../X86/Avx2/AndNot.Int16.cs                  | 19 ++++++++---
 .../X86/Avx2/AndNot.Int32.cs                  | 19 ++++++++---
 .../X86/Avx2/AndNot.Int64.cs                  | 19 ++++++++---
 .../X86/Avx2/AndNot.SByte.cs                  | 19 ++++++++---
 .../X86/Avx2/AndNot.UInt16.cs                 | 19 ++++++++---
 .../X86/Avx2/AndNot.UInt32.cs                 | 19 ++++++++---
 .../X86/Avx2/AndNot.UInt64.cs                 | 19 ++++++++---
 .../X86/Avx2/Average.Byte.cs                  | 19 ++++++++---
 .../X86/Avx2/Average.UInt16.cs                | 19 ++++++++---
 .../X86/Avx2/Blend.Int16.1.cs                 | 19 ++++++++---
 .../X86/Avx2/Blend.Int16.2.cs                 | 19 ++++++++---
 .../X86/Avx2/Blend.Int16.4.cs                 | 19 ++++++++---
 .../X86/Avx2/Blend.Int16.85.cs                | 19 ++++++++---
 .../X86/Avx2/Blend.Int32.1.cs                 | 19 ++++++++---
 .../X86/Avx2/Blend.Int32.2.cs                 | 19 ++++++++---
 .../X86/Avx2/Blend.Int32.4.cs                 | 19 ++++++++---
 .../X86/Avx2/Blend.Int32.85.cs                | 19 ++++++++---
 .../X86/Avx2/Blend.UInt16.1.cs                | 19 ++++++++---
 .../X86/Avx2/Blend.UInt16.2.cs                | 19 ++++++++---
 .../X86/Avx2/Blend.UInt16.4.cs                | 19 ++++++++---
 .../X86/Avx2/Blend.UInt16.85.cs               | 19 ++++++++---
 .../X86/Avx2/Blend.UInt32.1.cs                | 19 ++++++++---
 .../X86/Avx2/Blend.UInt32.2.cs                | 19 ++++++++---
 .../X86/Avx2/Blend.UInt32.4.cs                | 19 ++++++++---
 .../X86/Avx2/Blend.UInt32.85.cs               | 19 ++++++++---
 .../X86/Avx2/BlendVariable.Byte.cs            | 19 ++++++++---
 .../X86/Avx2/BlendVariable.Int16.cs           | 19 ++++++++---
 .../X86/Avx2/BlendVariable.Int32.cs           | 19 ++++++++---
 .../X86/Avx2/BlendVariable.Int64.cs           | 19 ++++++++---
 .../X86/Avx2/BlendVariable.SByte.cs           | 19 ++++++++---
 .../X86/Avx2/BlendVariable.UInt16.cs          | 19 ++++++++---
 .../X86/Avx2/BlendVariable.UInt32.cs          | 19 ++++++++---
 .../X86/Avx2/BlendVariable.UInt64.cs          | 19 ++++++++---
 .../Avx2/BroadcastScalarToVector128.Byte.cs   | 19 ++++++++---
 .../Avx2/BroadcastScalarToVector128.Double.cs | 19 ++++++++---
 .../Avx2/BroadcastScalarToVector128.Int16.cs  | 19 ++++++++---
 .../Avx2/BroadcastScalarToVector128.Int32.cs  | 19 ++++++++---
 .../Avx2/BroadcastScalarToVector128.Int64.cs  | 19 ++++++++---
 .../Avx2/BroadcastScalarToVector128.SByte.cs  | 19 ++++++++---
 .../Avx2/BroadcastScalarToVector128.Single.cs | 19 ++++++++---
 .../Avx2/BroadcastScalarToVector128.UInt16.cs | 19 ++++++++---
 .../Avx2/BroadcastScalarToVector128.UInt32.cs | 19 ++++++++---
 .../Avx2/BroadcastScalarToVector128.UInt64.cs | 19 ++++++++---
 .../Avx2/BroadcastScalarToVector256.Byte.cs   | 19 ++++++++---
 .../Avx2/BroadcastScalarToVector256.Double.cs | 19 ++++++++---
 .../Avx2/BroadcastScalarToVector256.Int16.cs  | 19 ++++++++---
 .../Avx2/BroadcastScalarToVector256.Int32.cs  | 19 ++++++++---
 .../Avx2/BroadcastScalarToVector256.Int64.cs  | 19 ++++++++---
 .../Avx2/BroadcastScalarToVector256.SByte.cs  | 19 ++++++++---
 .../Avx2/BroadcastScalarToVector256.Single.cs | 19 ++++++++---
 .../Avx2/BroadcastScalarToVector256.UInt16.cs | 19 ++++++++---
 .../Avx2/BroadcastScalarToVector256.UInt32.cs | 19 ++++++++---
 .../Avx2/BroadcastScalarToVector256.UInt64.cs | 19 ++++++++---
 .../X86/Avx2/CompareEqual.Byte.cs             | 19 ++++++++---
 .../X86/Avx2/CompareEqual.Int16.cs            | 19 ++++++++---
 .../X86/Avx2/CompareEqual.Int32.cs            | 19 ++++++++---
 .../X86/Avx2/CompareEqual.Int64.cs            | 19 ++++++++---
 .../X86/Avx2/CompareEqual.SByte.cs            | 19 ++++++++---
 .../X86/Avx2/CompareEqual.UInt16.cs           | 19 ++++++++---
 .../X86/Avx2/CompareEqual.UInt32.cs           | 19 ++++++++---
 .../X86/Avx2/CompareEqual.UInt64.cs           | 19 ++++++++---
 .../X86/Avx2/CompareGreaterThan.Int16.cs      | 19 ++++++++---
 .../X86/Avx2/CompareGreaterThan.Int32.cs      | 19 ++++++++---
 .../X86/Avx2/CompareGreaterThan.Int64.cs      | 19 ++++++++---
 .../X86/Avx2/CompareGreaterThan.SByte.cs      | 19 ++++++++---
 .../X86/Avx2/ConvertToInt32.Int32.cs          | 17 +++++++---
 .../X86/Avx2/ConvertToUInt32.UInt32.cs        | 17 +++++++---
 .../X86/Avx2/ExtractVector128.Byte.1.Store.cs | 19 ++++++++---
 .../X86/Avx2/ExtractVector128.Byte.1.cs       | 19 ++++++++---
 .../Avx2/ExtractVector128.Int16.1.Store.cs    | 19 ++++++++---
 .../X86/Avx2/ExtractVector128.Int16.1.cs      | 19 ++++++++---
 .../Avx2/ExtractVector128.Int32.1.Store.cs    | 19 ++++++++---
 .../X86/Avx2/ExtractVector128.Int32.1.cs      | 19 ++++++++---
 .../Avx2/ExtractVector128.Int64.1.Store.cs    | 19 ++++++++---
 .../X86/Avx2/ExtractVector128.Int64.1.cs      | 19 ++++++++---
 .../Avx2/ExtractVector128.SByte.1.Store.cs    | 19 ++++++++---
 .../X86/Avx2/ExtractVector128.SByte.1.cs      | 19 ++++++++---
 .../Avx2/ExtractVector128.UInt16.1.Store.cs   | 19 ++++++++---
 .../X86/Avx2/ExtractVector128.UInt16.1.cs     | 19 ++++++++---
 .../Avx2/ExtractVector128.UInt32.1.Store.cs   | 19 ++++++++---
 .../X86/Avx2/ExtractVector128.UInt32.1.cs     | 19 ++++++++---
 .../Avx2/ExtractVector128.UInt64.1.Store.cs   | 19 ++++++++---
 .../X86/Avx2/ExtractVector128.UInt64.1.cs     | 19 ++++++++---
 .../X86/Avx2/InsertVector128.Byte.1.Load.cs   | 19 ++++++++---
 .../X86/Avx2/InsertVector128.Byte.1.cs        | 19 ++++++++---
 .../X86/Avx2/InsertVector128.Int16.1.Load.cs  | 19 ++++++++---
 .../X86/Avx2/InsertVector128.Int16.1.cs       | 19 ++++++++---
 .../X86/Avx2/InsertVector128.Int32.1.Load.cs  | 19 ++++++++---
 .../X86/Avx2/InsertVector128.Int32.1.cs       | 19 ++++++++---
 .../X86/Avx2/InsertVector128.Int64.1.Load.cs  | 19 ++++++++---
 .../X86/Avx2/InsertVector128.Int64.1.cs       | 19 ++++++++---
 .../X86/Avx2/InsertVector128.SByte.1.Load.cs  | 19 ++++++++---
 .../X86/Avx2/InsertVector128.SByte.1.cs       | 19 ++++++++---
 .../X86/Avx2/InsertVector128.UInt16.1.Load.cs | 19 ++++++++---
 .../X86/Avx2/InsertVector128.UInt16.1.cs      | 19 ++++++++---
 .../X86/Avx2/InsertVector128.UInt32.1.Load.cs | 19 ++++++++---
 .../X86/Avx2/InsertVector128.UInt32.1.cs      | 19 ++++++++---
 .../X86/Avx2/InsertVector128.UInt64.1.Load.cs | 19 ++++++++---
 .../X86/Avx2/InsertVector128.UInt64.1.cs      | 19 ++++++++---
 .../X86/Avx2/MaskLoad.Int32.cs                | 19 ++++++++---
 .../X86/Avx2/MaskLoad.Int64.cs                | 19 ++++++++---
 .../X86/Avx2/MaskLoad.UInt32.cs               | 19 ++++++++---
 .../X86/Avx2/MaskLoad.UInt64.cs               | 19 ++++++++---
 .../X86/Avx2/MaskStore.Int32.cs               | 19 ++++++++---
 .../X86/Avx2/MaskStore.Int64.cs               | 19 ++++++++---
 .../X86/Avx2/MaskStore.UInt32.cs              | 19 ++++++++---
 .../X86/Avx2/MaskStore.UInt64.cs              | 19 ++++++++---
 .../HardwareIntrinsics/X86/Avx2/Max.Byte.cs   | 19 ++++++++---
 .../HardwareIntrinsics/X86/Avx2/Max.Int16.cs  | 19 ++++++++---
 .../HardwareIntrinsics/X86/Avx2/Max.Int32.cs  | 19 ++++++++---
 .../HardwareIntrinsics/X86/Avx2/Max.SByte.cs  | 19 ++++++++---
 .../HardwareIntrinsics/X86/Avx2/Max.UInt16.cs | 19 ++++++++---
 .../HardwareIntrinsics/X86/Avx2/Max.UInt32.cs | 19 ++++++++---
 .../HardwareIntrinsics/X86/Avx2/Min.Byte.cs   | 19 ++++++++---
 .../HardwareIntrinsics/X86/Avx2/Min.Int16.cs  | 19 ++++++++---
 .../HardwareIntrinsics/X86/Avx2/Min.Int32.cs  | 19 ++++++++---
 .../HardwareIntrinsics/X86/Avx2/Min.SByte.cs  | 19 ++++++++---
 .../HardwareIntrinsics/X86/Avx2/Min.UInt16.cs | 19 ++++++++---
 .../HardwareIntrinsics/X86/Avx2/Min.UInt32.cs | 19 ++++++++---
 ...MultipleSumAbsoluteDifferences.UInt16.0.cs | 19 ++++++++---
 .../X86/Avx2/MultiplyAddAdjacent.Int16.cs     | 19 ++++++++---
 .../X86/Avx2/MultiplyAddAdjacent.Int32.cs     | 19 ++++++++---
 .../X86/Avx2/MultiplyHigh.Int16.cs            | 19 ++++++++---
 .../X86/Avx2/MultiplyHigh.UInt16.cs           | 19 ++++++++---
 .../X86/Avx2/MultiplyHighRoundScale.Int16.cs  | 19 ++++++++---
 .../X86/Avx2/MultiplyLow.Int16.cs             | 19 ++++++++---
 .../X86/Avx2/MultiplyLow.Int32.cs             | 19 ++++++++---
 .../X86/Avx2/MultiplyLow.UInt16.cs            | 19 ++++++++---
 .../X86/Avx2/MultiplyLow.UInt32.cs            | 19 ++++++++---
 .../HardwareIntrinsics/X86/Avx2/Or.Byte.cs    | 19 ++++++++---
 .../HardwareIntrinsics/X86/Avx2/Or.Int16.cs   | 19 ++++++++---
 .../HardwareIntrinsics/X86/Avx2/Or.Int32.cs   | 19 ++++++++---
 .../HardwareIntrinsics/X86/Avx2/Or.Int64.cs   | 19 ++++++++---
 .../HardwareIntrinsics/X86/Avx2/Or.SByte.cs   | 19 ++++++++---
 .../HardwareIntrinsics/X86/Avx2/Or.UInt16.cs  | 19 ++++++++---
 .../HardwareIntrinsics/X86/Avx2/Or.UInt32.cs  | 19 ++++++++---
 .../HardwareIntrinsics/X86/Avx2/Or.UInt64.cs  | 19 ++++++++---
 .../X86/Avx2/PackSignedSaturate.Int16.cs      | 19 ++++++++---
 .../X86/Avx2/PackSignedSaturate.SByte.cs      | 19 ++++++++---
 .../X86/Avx2/PackUnsignedSaturate.Byte.cs     | 19 ++++++++---
 .../X86/Avx2/PackUnsignedSaturate.UInt16.cs   | 19 ++++++++---
 .../X86/Avx2/Permute2x128.Int32.2.cs          | 19 ++++++++---
 .../X86/Avx2/Permute2x128.Int64.2.cs          | 19 ++++++++---
 .../X86/Avx2/Permute2x128.UInt32.2.cs         | 19 ++++++++---
 .../X86/Avx2/Permute2x128.UInt64.2.cs         | 19 ++++++++---
 .../X86/Avx2/Permute4x64.Double.85.cs         | 19 ++++++++---
 .../X86/Avx2/Permute4x64.Int64.85.cs          | 19 ++++++++---
 .../X86/Avx2/Permute4x64.UInt64.85.cs         | 19 ++++++++---
 .../X86/Avx2/PermuteVar8x32.Int32.cs          | 19 ++++++++---
 .../X86/Avx2/PermuteVar8x32.Single.cs         | 19 ++++++++---
 .../X86/Avx2/PermuteVar8x32.UInt32.cs         | 19 ++++++++---
 .../X86/Avx2/ShiftLeftLogical.Int16.1.cs      | 19 ++++++++---
 .../X86/Avx2/ShiftLeftLogical.Int16.16.cs     | 19 ++++++++---
 .../X86/Avx2/ShiftLeftLogical.Int32.1.cs      | 19 ++++++++---
 .../X86/Avx2/ShiftLeftLogical.Int32.32.cs     | 19 ++++++++---
 .../X86/Avx2/ShiftLeftLogical.Int64.1.cs      | 19 ++++++++---
 .../X86/Avx2/ShiftLeftLogical.Int64.64.cs     | 19 ++++++++---
 .../X86/Avx2/ShiftLeftLogical.UInt16.1.cs     | 19 ++++++++---
 .../X86/Avx2/ShiftLeftLogical.UInt16.16.cs    | 19 ++++++++---
 .../X86/Avx2/ShiftLeftLogical.UInt32.1.cs     | 19 ++++++++---
 .../X86/Avx2/ShiftLeftLogical.UInt32.32.cs    | 19 ++++++++---
 .../X86/Avx2/ShiftLeftLogical.UInt64.1.cs     | 19 ++++++++---
 .../X86/Avx2/ShiftLeftLogical.UInt64.64.cs    | 19 ++++++++---
 .../Avx2/ShiftLeftLogical128BitLane.Byte.1.cs | 19 ++++++++---
 .../ShiftLeftLogical128BitLane.Int16.1.cs     | 19 ++++++++---
 .../ShiftLeftLogical128BitLane.Int32.1.cs     | 19 ++++++++---
 .../ShiftLeftLogical128BitLane.Int64.1.cs     | 19 ++++++++---
 .../ShiftLeftLogical128BitLane.SByte.1.cs     | 19 ++++++++---
 .../ShiftLeftLogical128BitLane.UInt16.1.cs    | 19 ++++++++---
 .../ShiftLeftLogical128BitLane.UInt32.1.cs    | 19 ++++++++---
 .../ShiftLeftLogical128BitLane.UInt64.1.cs    | 19 ++++++++---
 .../X86/Avx2/ShiftRightArithmetic.Int16.1.cs  | 19 ++++++++---
 .../X86/Avx2/ShiftRightArithmetic.Int16.16.cs | 19 ++++++++---
 .../X86/Avx2/ShiftRightArithmetic.Int32.1.cs  | 19 ++++++++---
 .../X86/Avx2/ShiftRightArithmetic.Int32.32.cs | 19 ++++++++---
 .../ShiftRightArithmeticVariable.Int32.cs     | 19 ++++++++---
 .../X86/Avx2/ShiftRightLogical.Int16.1.cs     | 19 ++++++++---
 .../X86/Avx2/ShiftRightLogical.Int16.16.cs    | 19 ++++++++---
 .../X86/Avx2/ShiftRightLogical.Int32.1.cs     | 19 ++++++++---
 .../X86/Avx2/ShiftRightLogical.Int32.32.cs    | 19 ++++++++---
 .../X86/Avx2/ShiftRightLogical.Int64.1.cs     | 19 ++++++++---
 .../X86/Avx2/ShiftRightLogical.Int64.64.cs    | 19 ++++++++---
 .../X86/Avx2/ShiftRightLogical.UInt16.1.cs    | 19 ++++++++---
 .../X86/Avx2/ShiftRightLogical.UInt16.16.cs   | 19 ++++++++---
 .../X86/Avx2/ShiftRightLogical.UInt32.1.cs    | 19 ++++++++---
 .../X86/Avx2/ShiftRightLogical.UInt32.32.cs   | 19 ++++++++---
 .../X86/Avx2/ShiftRightLogical.UInt64.1.cs    | 19 ++++++++---
 .../X86/Avx2/ShiftRightLogical.UInt64.64.cs   | 19 ++++++++---
 .../ShiftRightLogical128BitLane.Byte.1.cs     | 19 ++++++++---
 .../ShiftRightLogical128BitLane.Int16.1.cs    | 19 ++++++++---
 .../ShiftRightLogical128BitLane.Int32.1.cs    | 19 ++++++++---
 .../ShiftRightLogical128BitLane.Int64.1.cs    | 19 ++++++++---
 .../ShiftRightLogical128BitLane.SByte.1.cs    | 19 ++++++++---
 .../ShiftRightLogical128BitLane.UInt16.1.cs   | 19 ++++++++---
 .../ShiftRightLogical128BitLane.UInt32.1.cs   | 19 ++++++++---
 .../ShiftRightLogical128BitLane.UInt64.1.cs   | 19 ++++++++---
 .../X86/Avx2/Shuffle.Byte.cs                  | 19 ++++++++---
 .../X86/Avx2/Shuffle.Int32.1.cs               | 19 ++++++++---
 .../X86/Avx2/Shuffle.SByte.cs                 | 19 ++++++++---
 .../X86/Avx2/Shuffle.UInt32.1.cs              | 19 ++++++++---
 .../X86/Avx2/ShuffleHigh.Int16.228.cs         | 19 ++++++++---
 .../X86/Avx2/ShuffleHigh.UInt16.228.cs        | 19 ++++++++---
 .../X86/Avx2/ShuffleLow.Int16.228.cs          | 19 ++++++++---
 .../X86/Avx2/ShuffleLow.UInt16.228.cs         | 19 ++++++++---
 .../HardwareIntrinsics/X86/Avx2/Sign.Int16.cs | 19 ++++++++---
 .../HardwareIntrinsics/X86/Avx2/Sign.Int32.cs | 19 ++++++++---
 .../HardwareIntrinsics/X86/Avx2/Sign.SByte.cs | 19 ++++++++---
 .../X86/Avx2/Subtract.Byte.cs                 | 19 ++++++++---
 .../X86/Avx2/Subtract.Int16.cs                | 19 ++++++++---
 .../X86/Avx2/Subtract.Int32.cs                | 19 ++++++++---
 .../X86/Avx2/Subtract.Int64.cs                | 19 ++++++++---
 .../X86/Avx2/Subtract.SByte.cs                | 19 ++++++++---
 .../X86/Avx2/Subtract.UInt16.cs               | 19 ++++++++---
 .../X86/Avx2/Subtract.UInt32.cs               | 19 ++++++++---
 .../X86/Avx2/Subtract.UInt64.cs               | 19 ++++++++---
 .../X86/Avx2/SumAbsoluteDifferences.UInt16.cs | 19 ++++++++---
 .../HardwareIntrinsics/X86/Avx2/Xor.Byte.cs   | 19 ++++++++---
 .../HardwareIntrinsics/X86/Avx2/Xor.Int16.cs  | 19 ++++++++---
 .../HardwareIntrinsics/X86/Avx2/Xor.Int32.cs  | 19 ++++++++---
 .../HardwareIntrinsics/X86/Avx2/Xor.Int64.cs  | 19 ++++++++---
 .../HardwareIntrinsics/X86/Avx2/Xor.SByte.cs  | 19 ++++++++---
 .../HardwareIntrinsics/X86/Avx2/Xor.UInt16.cs | 19 ++++++++---
 .../HardwareIntrinsics/X86/Avx2/Xor.UInt32.cs | 19 ++++++++---
 .../HardwareIntrinsics/X86/Avx2/Xor.UInt64.cs | 19 ++++++++---
 .../X86/Avx2_Vector128/Blend.Int32.1.cs       | 19 ++++++++---
 .../X86/Avx2_Vector128/Blend.Int32.2.cs       | 19 ++++++++---
 .../X86/Avx2_Vector128/Blend.Int32.4.cs       | 19 ++++++++---
 .../X86/Avx2_Vector128/Blend.Int32.85.cs      | 19 ++++++++---
 .../X86/Avx2_Vector128/Blend.UInt32.1.cs      | 19 ++++++++---
 .../X86/Avx2_Vector128/Blend.UInt32.2.cs      | 19 ++++++++---
 .../X86/Avx2_Vector128/Blend.UInt32.4.cs      | 19 ++++++++---
 .../X86/Avx2_Vector128/Blend.UInt32.85.cs     | 19 ++++++++---
 .../BroadcastScalarToVector128.Byte.cs        | 10 ++++--
 .../BroadcastScalarToVector128.Int16.cs       | 10 ++++--
 .../BroadcastScalarToVector128.Int32.cs       | 10 ++++--
 .../BroadcastScalarToVector128.Int64.cs       | 10 ++++--
 .../BroadcastScalarToVector128.SByte.cs       | 10 ++++--
 .../BroadcastScalarToVector128.UInt16.cs      | 10 ++++--
 .../BroadcastScalarToVector128.UInt32.cs      | 10 ++++--
 .../BroadcastScalarToVector128.UInt64.cs      | 10 ++++--
 .../BroadcastScalarToVector256.Byte.cs        | 10 ++++--
 .../BroadcastScalarToVector256.Int16.cs       | 10 ++++--
 .../BroadcastScalarToVector256.Int32.cs       | 10 ++++--
 .../BroadcastScalarToVector256.Int64.cs       | 10 ++++--
 .../BroadcastScalarToVector256.SByte.cs       | 10 ++++--
 .../BroadcastScalarToVector256.UInt16.cs      | 10 ++++--
 .../BroadcastScalarToVector256.UInt32.cs      | 10 ++++--
 .../BroadcastScalarToVector256.UInt64.cs      | 10 ++++--
 .../X86/Avx2_Vector128/MaskLoad.Int32.cs      | 19 ++++++++---
 .../X86/Avx2_Vector128/MaskLoad.Int64.cs      | 19 ++++++++---
 .../X86/Avx2_Vector128/MaskLoad.UInt32.cs     | 19 ++++++++---
 .../X86/Avx2_Vector128/MaskLoad.UInt64.cs     | 19 ++++++++---
 .../X86/Avx2_Vector128/MaskStore.Int32.cs     | 19 ++++++++---
 .../X86/Avx2_Vector128/MaskStore.Int64.cs     | 19 ++++++++---
 .../X86/Avx2_Vector128/MaskStore.UInt32.cs    | 19 ++++++++---
 .../X86/Avx2_Vector128/MaskStore.UInt64.cs    | 19 ++++++++---
 .../ShiftRightArithmeticVariable.Int32.cs     | 19 ++++++++---
 .../X86/Avx_Vector128/MaskLoad.Double.cs      | 19 ++++++++---
 .../X86/Avx_Vector128/MaskLoad.Single.cs      | 19 ++++++++---
 .../X86/Avx_Vector128/MaskStore.Double.cs     | 19 ++++++++---
 .../X86/Avx_Vector128/MaskStore.Single.cs     | 19 ++++++++---
 .../X86/Bmi1/AndNot.UInt32.cs                 | 11 +++++--
 .../X86/Bmi1/AndNot.UInt64.cs                 | 11 +++++--
 .../X86/Bmi1/ExtractLowestSetBit.UInt32.cs    | 11 +++++--
 .../X86/Bmi1/ExtractLowestSetBit.UInt64.cs    | 11 +++++--
 .../Bmi1/GetMaskUpToLowestSetBit.UInt32.cs    | 11 +++++--
 .../Bmi1/GetMaskUpToLowestSetBit.UInt64.cs    | 11 +++++--
 .../X86/Bmi1/ResetLowestSetBit.UInt32.cs      | 11 +++++--
 .../X86/Bmi1/ResetLowestSetBit.UInt64.cs      | 11 +++++--
 .../X86/Bmi1/TrailingZeroCount.UInt32.cs      | 11 +++++--
 .../X86/Bmi1/TrailingZeroCount.UInt64.cs      | 11 +++++--
 .../X86/Bmi2/ParallelBitDeposit.UInt32.cs     | 11 +++++--
 .../X86/Bmi2/ParallelBitDeposit.UInt64.cs     | 11 +++++--
 .../X86/Bmi2/ParallelBitExtract.UInt32.cs     | 11 +++++--
 .../X86/Bmi2/ParallelBitExtract.UInt64.cs     | 11 +++++--
 .../X86/Fma_Vector128/MultiplyAdd.Double.cs   | 19 ++++++++---
 .../X86/Fma_Vector128/MultiplyAdd.Single.cs   | 19 ++++++++---
 .../MultiplyAddNegated.Double.cs              | 19 ++++++++---
 .../MultiplyAddNegated.Single.cs              | 19 ++++++++---
 .../MultiplyAddNegatedScalar.Double.cs        | 19 ++++++++---
 .../MultiplyAddNegatedScalar.Single.cs        | 19 ++++++++---
 .../Fma_Vector128/MultiplyAddScalar.Double.cs | 19 ++++++++---
 .../Fma_Vector128/MultiplyAddScalar.Single.cs | 19 ++++++++---
 .../MultiplyAddSubtract.Double.cs             | 19 ++++++++---
 .../MultiplyAddSubtract.Single.cs             | 19 ++++++++---
 .../Fma_Vector128/MultiplySubtract.Double.cs  | 19 ++++++++---
 .../Fma_Vector128/MultiplySubtract.Single.cs  | 19 ++++++++---
 .../MultiplySubtractAdd.Double.cs             | 19 ++++++++---
 .../MultiplySubtractAdd.Single.cs             | 19 ++++++++---
 .../MultiplySubtractNegated.Double.cs         | 19 ++++++++---
 .../MultiplySubtractNegated.Single.cs         | 19 ++++++++---
 .../MultiplySubtractNegatedScalar.Double.cs   | 19 ++++++++---
 .../MultiplySubtractNegatedScalar.Single.cs   | 19 ++++++++---
 .../MultiplySubtractScalar.Double.cs          | 19 ++++++++---
 .../MultiplySubtractScalar.Single.cs          | 19 ++++++++---
 .../X86/Fma_Vector256/MultiplyAdd.Double.cs   | 19 ++++++++---
 .../X86/Fma_Vector256/MultiplyAdd.Single.cs   | 19 ++++++++---
 .../MultiplyAddNegated.Double.cs              | 19 ++++++++---
 .../MultiplyAddNegated.Single.cs              | 19 ++++++++---
 .../MultiplyAddSubtract.Double.cs             | 19 ++++++++---
 .../MultiplyAddSubtract.Single.cs             | 19 ++++++++---
 .../Fma_Vector256/MultiplySubtract.Double.cs  | 19 ++++++++---
 .../Fma_Vector256/MultiplySubtract.Single.cs  | 19 ++++++++---
 .../MultiplySubtractAdd.Double.cs             | 19 ++++++++---
 .../MultiplySubtractAdd.Single.cs             | 19 ++++++++---
 .../MultiplySubtractNegated.Double.cs         | 19 ++++++++---
 .../MultiplySubtractNegated.Single.cs         | 19 ++++++++---
 .../Pclmulqdq/CarrylessMultiply.Int64.0.cs    | 18 ++++++++---
 .../Pclmulqdq/CarrylessMultiply.Int64.1.cs    | 18 ++++++++---
 .../Pclmulqdq/CarrylessMultiply.Int64.129.cs  | 18 ++++++++---
 .../Pclmulqdq/CarrylessMultiply.Int64.16.cs   | 18 ++++++++---
 .../Pclmulqdq/CarrylessMultiply.Int64.17.cs   | 18 ++++++++---
 .../Pclmulqdq/CarrylessMultiply.UInt64.0.cs   | 18 ++++++++---
 .../Pclmulqdq/CarrylessMultiply.UInt64.1.cs   | 18 ++++++++---
 .../Pclmulqdq/CarrylessMultiply.UInt64.129.cs | 18 ++++++++---
 .../Pclmulqdq/CarrylessMultiply.UInt64.16.cs  | 18 ++++++++---
 .../Pclmulqdq/CarrylessMultiply.UInt64.17.cs  | 18 ++++++++---
 .../HardwareIntrinsics/X86/Sse/Add.Single.cs  | 19 ++++++++---
 .../X86/Sse/AddScalar.Single.cs               | 19 ++++++++---
 .../HardwareIntrinsics/X86/Sse/And.Single.cs  | 19 ++++++++---
 .../X86/Sse/AndNot.Single.cs                  | 19 ++++++++---
 .../X86/Sse/CompareEqual.Single.cs            | 19 ++++++++---
 .../Sse/CompareEqualOrderedScalar.Boolean.cs  | 13 +++++---
 .../X86/Sse/CompareEqualScalar.Single.cs      | 19 ++++++++---
 .../CompareEqualUnorderedScalar.Boolean.cs    | 13 +++++---
 .../X86/Sse/CompareGreaterThan.Single.cs      | 19 ++++++++---
 .../Sse/CompareGreaterThanOrEqual.Single.cs   | 19 ++++++++---
 ...GreaterThanOrEqualOrderedScalar.Boolean.cs | 13 +++++---
 .../CompareGreaterThanOrEqualScalar.Single.cs | 19 ++++++++---
 ...eaterThanOrEqualUnorderedScalar.Boolean.cs | 13 +++++---
 ...CompareGreaterThanOrderedScalar.Boolean.cs | 13 +++++---
 .../Sse/CompareGreaterThanScalar.Single.cs    | 19 ++++++++---
 ...mpareGreaterThanUnorderedScalar.Boolean.cs | 13 +++++---
 .../X86/Sse/CompareLessThan.Single.cs         | 19 ++++++++---
 .../X86/Sse/CompareLessThanOrEqual.Single.cs  | 19 ++++++++---
 ...areLessThanOrEqualOrderedScalar.Boolean.cs | 13 +++++---
 .../CompareLessThanOrEqualScalar.Single.cs    | 19 ++++++++---
 ...eLessThanOrEqualUnorderedScalar.Boolean.cs | 13 +++++---
 .../CompareLessThanOrderedScalar.Boolean.cs   | 13 +++++---
 .../X86/Sse/CompareLessThanScalar.Single.cs   | 19 ++++++++---
 .../CompareLessThanUnorderedScalar.Boolean.cs | 13 +++++---
 .../X86/Sse/CompareNotEqual.Single.cs         | 19 ++++++++---
 .../CompareNotEqualOrderedScalar.Boolean.cs   | 13 +++++---
 .../X86/Sse/CompareNotEqualScalar.Single.cs   | 19 ++++++++---
 .../CompareNotEqualUnorderedScalar.Boolean.cs | 13 +++++---
 .../X86/Sse/CompareNotGreaterThan.Single.cs   | 19 ++++++++---
 .../CompareNotGreaterThanOrEqual.Single.cs    | 19 ++++++++---
 ...mpareNotGreaterThanOrEqualScalar.Single.cs | 19 ++++++++---
 .../Sse/CompareNotGreaterThanScalar.Single.cs | 19 ++++++++---
 .../X86/Sse/CompareNotLessThan.Single.cs      | 19 ++++++++---
 .../Sse/CompareNotLessThanOrEqual.Single.cs   | 19 ++++++++---
 .../CompareNotLessThanOrEqualScalar.Single.cs | 19 ++++++++---
 .../Sse/CompareNotLessThanScalar.Single.cs    | 19 ++++++++---
 .../X86/Sse/CompareOrdered.Single.cs          | 19 ++++++++---
 .../X86/Sse/CompareOrderedScalar.Single.cs    | 19 ++++++++---
 .../X86/Sse/CompareUnordered.Single.cs        | 19 ++++++++---
 .../X86/Sse/CompareUnorderedScalar.Single.cs  | 19 ++++++++---
 .../X86/Sse/Divide.Single.cs                  | 19 ++++++++---
 .../X86/Sse/DivideScalar.Single.cs            | 19 ++++++++---
 .../X86/Sse/LoadScalarVector128.Single.cs     | 10 ++++--
 .../X86/Sse/LoadVector128.Single.cs           | 10 ++++--
 .../HardwareIntrinsics/X86/Sse/Max.Single.cs  | 19 ++++++++---
 .../X86/Sse/MaxScalar.Single.cs               | 19 ++++++++---
 .../HardwareIntrinsics/X86/Sse/Min.Single.cs  | 19 ++++++++---
 .../X86/Sse/MinScalar.Single.cs               | 19 ++++++++---
 .../X86/Sse/Multiply.Single.cs                | 19 ++++++++---
 .../X86/Sse/MultiplyScalar.Single.cs          | 19 ++++++++---
 .../HardwareIntrinsics/X86/Sse/Or.Single.cs   | 19 ++++++++---
 .../X86/Sse/Subtract.Single.cs                | 19 ++++++++---
 .../X86/Sse/SubtractScalar.Single.cs          | 19 ++++++++---
 .../HardwareIntrinsics/X86/Sse/Xor.Single.cs  | 19 ++++++++---
 .../HardwareIntrinsics/X86/Sse2/Add.Byte.cs   | 19 ++++++++---
 .../HardwareIntrinsics/X86/Sse2/Add.Double.cs | 19 ++++++++---
 .../HardwareIntrinsics/X86/Sse2/Add.Int16.cs  | 19 ++++++++---
 .../HardwareIntrinsics/X86/Sse2/Add.Int32.cs  | 19 ++++++++---
 .../HardwareIntrinsics/X86/Sse2/Add.Int64.cs  | 19 ++++++++---
 .../HardwareIntrinsics/X86/Sse2/Add.SByte.cs  | 19 ++++++++---
 .../HardwareIntrinsics/X86/Sse2/Add.UInt16.cs | 19 ++++++++---
 .../HardwareIntrinsics/X86/Sse2/Add.UInt32.cs | 19 ++++++++---
 .../HardwareIntrinsics/X86/Sse2/Add.UInt64.cs | 19 ++++++++---
 .../X86/Sse2/AddSaturate.Byte.cs              | 19 ++++++++---
 .../X86/Sse2/AddSaturate.Int16.cs             | 19 ++++++++---
 .../X86/Sse2/AddSaturate.SByte.cs             | 19 ++++++++---
 .../X86/Sse2/AddSaturate.UInt16.cs            | 19 ++++++++---
 .../X86/Sse2/AddScalar.Double.cs              | 19 ++++++++---
 .../HardwareIntrinsics/X86/Sse2/And.Byte.cs   | 19 ++++++++---
 .../HardwareIntrinsics/X86/Sse2/And.Double.cs | 19 ++++++++---
 .../HardwareIntrinsics/X86/Sse2/And.Int16.cs  | 19 ++++++++---
 .../HardwareIntrinsics/X86/Sse2/And.Int32.cs  | 19 ++++++++---
 .../HardwareIntrinsics/X86/Sse2/And.Int64.cs  | 19 ++++++++---
 .../HardwareIntrinsics/X86/Sse2/And.SByte.cs  | 19 ++++++++---
 .../HardwareIntrinsics/X86/Sse2/And.UInt16.cs | 19 ++++++++---
 .../HardwareIntrinsics/X86/Sse2/And.UInt32.cs | 19 ++++++++---
 .../HardwareIntrinsics/X86/Sse2/And.UInt64.cs | 19 ++++++++---
 .../X86/Sse2/AndNot.Byte.cs                   | 19 ++++++++---
 .../X86/Sse2/AndNot.Double.cs                 | 19 ++++++++---
 .../X86/Sse2/AndNot.Int16.cs                  | 19 ++++++++---
 .../X86/Sse2/AndNot.Int32.cs                  | 19 ++++++++---
 .../X86/Sse2/AndNot.Int64.cs                  | 19 ++++++++---
 .../X86/Sse2/AndNot.SByte.cs                  | 19 ++++++++---
 .../X86/Sse2/AndNot.UInt16.cs                 | 19 ++++++++---
 .../X86/Sse2/AndNot.UInt32.cs                 | 19 ++++++++---
 .../X86/Sse2/AndNot.UInt64.cs                 | 19 ++++++++---
 .../X86/Sse2/Average.Byte.cs                  | 19 ++++++++---
 .../X86/Sse2/Average.UInt16.cs                | 19 ++++++++---
 .../X86/Sse2/CompareEqual.Byte.cs             | 19 ++++++++---
 .../X86/Sse2/CompareEqual.Double.cs           | 19 ++++++++---
 .../X86/Sse2/CompareEqual.Int16.cs            | 19 ++++++++---
 .../X86/Sse2/CompareEqual.Int32.cs            | 19 ++++++++---
 .../X86/Sse2/CompareEqual.SByte.cs            | 19 ++++++++---
 .../X86/Sse2/CompareEqual.UInt16.cs           | 19 ++++++++---
 .../X86/Sse2/CompareEqual.UInt32.cs           | 19 ++++++++---
 .../Sse2/CompareEqualOrderedScalar.Boolean.cs | 13 +++++---
 .../X86/Sse2/CompareEqualScalar.Double.cs     | 19 ++++++++---
 .../CompareEqualUnorderedScalar.Boolean.cs    | 13 +++++---
 .../X86/Sse2/CompareGreaterThan.Double.cs     | 19 ++++++++---
 .../X86/Sse2/CompareGreaterThan.Int16.cs      | 19 ++++++++---
 .../X86/Sse2/CompareGreaterThan.Int32.cs      | 19 ++++++++---
 .../X86/Sse2/CompareGreaterThan.SByte.cs      | 19 ++++++++---
 .../Sse2/CompareGreaterThanOrEqual.Double.cs  | 19 ++++++++---
 ...GreaterThanOrEqualOrderedScalar.Boolean.cs | 13 +++++---
 .../CompareGreaterThanOrEqualScalar.Double.cs | 19 ++++++++---
 ...eaterThanOrEqualUnorderedScalar.Boolean.cs | 13 +++++---
 ...CompareGreaterThanOrderedScalar.Boolean.cs | 13 +++++---
 .../Sse2/CompareGreaterThanScalar.Double.cs   | 19 ++++++++---
 ...mpareGreaterThanUnorderedScalar.Boolean.cs | 13 +++++---
 .../X86/Sse2/CompareLessThan.Double.cs        | 19 ++++++++---
 .../X86/Sse2/CompareLessThan.Int16.cs         | 19 ++++++++---
 .../X86/Sse2/CompareLessThan.Int32.cs         | 19 ++++++++---
 .../X86/Sse2/CompareLessThan.SByte.cs         | 19 ++++++++---
 .../X86/Sse2/CompareLessThanOrEqual.Double.cs | 19 ++++++++---
 ...areLessThanOrEqualOrderedScalar.Boolean.cs | 13 +++++---
 .../CompareLessThanOrEqualScalar.Double.cs    | 19 ++++++++---
 ...eLessThanOrEqualUnorderedScalar.Boolean.cs | 13 +++++---
 .../CompareLessThanOrderedScalar.Boolean.cs   | 13 +++++---
 .../X86/Sse2/CompareLessThanScalar.Double.cs  | 19 ++++++++---
 .../CompareLessThanUnorderedScalar.Boolean.cs | 13 +++++---
 .../X86/Sse2/CompareNotEqual.Double.cs        | 19 ++++++++---
 .../CompareNotEqualOrderedScalar.Boolean.cs   | 13 +++++---
 .../X86/Sse2/CompareNotEqualScalar.Double.cs  | 19 ++++++++---
 .../CompareNotEqualUnorderedScalar.Boolean.cs | 13 +++++---
 .../X86/Sse2/CompareNotGreaterThan.Double.cs  | 19 ++++++++---
 .../CompareNotGreaterThanOrEqual.Double.cs    | 19 ++++++++---
 ...mpareNotGreaterThanOrEqualScalar.Double.cs | 19 ++++++++---
 .../CompareNotGreaterThanScalar.Double.cs     | 19 ++++++++---
 .../X86/Sse2/CompareNotLessThan.Double.cs     | 19 ++++++++---
 .../Sse2/CompareNotLessThanOrEqual.Double.cs  | 19 ++++++++---
 .../CompareNotLessThanOrEqualScalar.Double.cs | 19 ++++++++---
 .../Sse2/CompareNotLessThanScalar.Double.cs   | 19 ++++++++---
 .../X86/Sse2/CompareOrdered.Double.cs         | 19 ++++++++---
 .../X86/Sse2/CompareOrderedScalar.Double.cs   | 19 ++++++++---
 .../X86/Sse2/CompareUnordered.Double.cs       | 19 ++++++++---
 .../X86/Sse2/CompareUnorderedScalar.Double.cs | 19 ++++++++---
 .../Sse2/ConvertToInt32.Vector128Double.cs    | 17 +++++++---
 .../X86/Sse2/ConvertToInt32.Vector128Int32.cs | 17 +++++++---
 ...rtToInt32WithTruncation.Vector128Double.cs | 17 +++++++---
 .../Sse2/ConvertToInt64.Vector128Double.cs    | 17 +++++++---
 .../X86/Sse2/ConvertToInt64.Vector128Int64.cs | 17 +++++++---
 ...rtToInt64WithTruncation.Vector128Double.cs | 17 +++++++---
 .../Sse2/ConvertToUInt32.Vector128UInt32.cs   | 17 +++++++---
 .../Sse2/ConvertToUInt64.Vector128UInt64.cs   | 17 +++++++---
 ...ConvertToVector128Double.Vector128Int32.cs | 19 ++++++++---
 ...onvertToVector128Double.Vector128Single.cs | 19 ++++++++---
 ...ConvertToVector128Int32.Vector128Double.cs | 19 ++++++++---
 ...ConvertToVector128Int32.Vector128Single.cs | 19 ++++++++---
 ...r128Int32WithTruncation.Vector128Double.cs | 19 ++++++++---
 ...r128Int32WithTruncation.Vector128Single.cs | 19 ++++++++---
 ...onvertToVector128Single.Vector128Double.cs | 19 ++++++++---
 ...ConvertToVector128Single.Vector128Int32.cs | 19 ++++++++---
 .../X86/Sse2/Divide.Double.cs                 | 19 ++++++++---
 .../X86/Sse2/DivideScalar.Double.cs           | 19 ++++++++---
 .../X86/Sse2/Extract.UInt16.1.cs              | 17 +++++++---
 .../X86/Sse2/Extract.UInt16.129.cs            | 17 +++++++---
 .../X86/Sse2/Insert.Int16.1.cs                | 16 +++++++---
 .../X86/Sse2/Insert.Int16.129.cs              | 16 +++++++---
 .../X86/Sse2/Insert.UInt16.1.cs               | 16 +++++++---
 .../X86/Sse2/Insert.UInt16.129.cs             | 16 +++++++---
 .../X86/Sse2/LoadScalarVector128.Double.cs    | 10 ++++--
 .../X86/Sse2/LoadScalarVector128.Int32.cs     | 10 ++++--
 .../X86/Sse2/LoadScalarVector128.Int64.cs     | 10 ++++--
 .../X86/Sse2/LoadScalarVector128.UInt32.cs    | 10 ++++--
 .../X86/Sse2/LoadScalarVector128.UInt64.cs    | 10 ++++--
 .../X86/Sse2/LoadVector128.Byte.cs            | 10 ++++--
 .../X86/Sse2/LoadVector128.Double.cs          | 10 ++++--
 .../X86/Sse2/LoadVector128.Int16.cs           | 10 ++++--
 .../X86/Sse2/LoadVector128.Int32.cs           | 10 ++++--
 .../X86/Sse2/LoadVector128.Int64.cs           | 10 ++++--
 .../X86/Sse2/LoadVector128.SByte.cs           | 10 ++++--
 .../X86/Sse2/LoadVector128.UInt16.cs          | 10 ++++--
 .../X86/Sse2/LoadVector128.UInt32.cs          | 10 ++++--
 .../X86/Sse2/LoadVector128.UInt64.cs          | 10 ++++--
 .../HardwareIntrinsics/X86/Sse2/Max.Byte.cs   | 19 ++++++++---
 .../HardwareIntrinsics/X86/Sse2/Max.Double.cs | 19 ++++++++---
 .../HardwareIntrinsics/X86/Sse2/Max.Int16.cs  | 19 ++++++++---
 .../X86/Sse2/MaxScalar.Double.cs              | 19 ++++++++---
 .../HardwareIntrinsics/X86/Sse2/Min.Byte.cs   | 19 ++++++++---
 .../HardwareIntrinsics/X86/Sse2/Min.Double.cs | 19 ++++++++---
 .../HardwareIntrinsics/X86/Sse2/Min.Int16.cs  | 19 ++++++++---
 .../X86/Sse2/MinScalar.Double.cs              | 19 ++++++++---
 .../X86/Sse2/Multiply.Double.cs               | 19 ++++++++---
 .../X86/Sse2/MultiplyAddAdjacent.Int32.cs     | 19 ++++++++---
 .../X86/Sse2/MultiplyLow.Int16.cs             | 19 ++++++++---
 .../X86/Sse2/MultiplyLow.UInt16.cs            | 19 ++++++++---
 .../X86/Sse2/MultiplyScalar.Double.cs         | 19 ++++++++---
 .../HardwareIntrinsics/X86/Sse2/Or.Byte.cs    | 19 ++++++++---
 .../HardwareIntrinsics/X86/Sse2/Or.Double.cs  | 19 ++++++++---
 .../HardwareIntrinsics/X86/Sse2/Or.Int16.cs   | 19 ++++++++---
 .../HardwareIntrinsics/X86/Sse2/Or.Int32.cs   | 19 ++++++++---
 .../HardwareIntrinsics/X86/Sse2/Or.Int64.cs   | 19 ++++++++---
 .../HardwareIntrinsics/X86/Sse2/Or.SByte.cs   | 19 ++++++++---
 .../HardwareIntrinsics/X86/Sse2/Or.UInt16.cs  | 19 ++++++++---
 .../HardwareIntrinsics/X86/Sse2/Or.UInt32.cs  | 19 ++++++++---
 .../HardwareIntrinsics/X86/Sse2/Or.UInt64.cs  | 19 ++++++++---
 .../X86/Sse2/PackSignedSaturate.Int16.cs      | 19 ++++++++---
 .../X86/Sse2/PackSignedSaturate.SByte.cs      | 19 ++++++++---
 .../X86/Sse2/PackUnsignedSaturate.Byte.cs     | 19 ++++++++---
 .../X86/Sse2/ShiftLeftLogical.Int16.1.cs      | 19 ++++++++---
 .../X86/Sse2/ShiftLeftLogical.Int16.16.cs     | 19 ++++++++---
 .../X86/Sse2/ShiftLeftLogical.Int32.1.cs      | 19 ++++++++---
 .../X86/Sse2/ShiftLeftLogical.Int32.32.cs     | 19 ++++++++---
 .../X86/Sse2/ShiftLeftLogical.Int64.1.cs      | 19 ++++++++---
 .../X86/Sse2/ShiftLeftLogical.Int64.64.cs     | 19 ++++++++---
 .../X86/Sse2/ShiftLeftLogical.UInt16.1.cs     | 19 ++++++++---
 .../X86/Sse2/ShiftLeftLogical.UInt16.16.cs    | 19 ++++++++---
 .../X86/Sse2/ShiftLeftLogical.UInt32.1.cs     | 19 ++++++++---
 .../X86/Sse2/ShiftLeftLogical.UInt32.32.cs    | 19 ++++++++---
 .../X86/Sse2/ShiftLeftLogical.UInt64.1.cs     | 19 ++++++++---
 .../X86/Sse2/ShiftLeftLogical.UInt64.64.cs    | 19 ++++++++---
 .../Sse2/ShiftLeftLogical128BitLane.Byte.1.cs | 19 ++++++++---
 .../ShiftLeftLogical128BitLane.Int16.1.cs     | 19 ++++++++---
 .../ShiftLeftLogical128BitLane.Int32.1.cs     | 19 ++++++++---
 .../ShiftLeftLogical128BitLane.Int64.1.cs     | 19 ++++++++---
 .../ShiftLeftLogical128BitLane.SByte.1.cs     | 19 ++++++++---
 .../ShiftLeftLogical128BitLane.UInt16.1.cs    | 19 ++++++++---
 .../ShiftLeftLogical128BitLane.UInt32.1.cs    | 19 ++++++++---
 .../ShiftLeftLogical128BitLane.UInt64.1.cs    | 19 ++++++++---
 .../X86/Sse2/ShiftRightArithmetic.Int16.1.cs  | 19 ++++++++---
 .../X86/Sse2/ShiftRightArithmetic.Int16.16.cs | 19 ++++++++---
 .../X86/Sse2/ShiftRightArithmetic.Int32.1.cs  | 19 ++++++++---
 .../X86/Sse2/ShiftRightArithmetic.Int32.32.cs | 19 ++++++++---
 .../X86/Sse2/ShiftRightLogical.Int16.1.cs     | 19 ++++++++---
 .../X86/Sse2/ShiftRightLogical.Int16.16.cs    | 19 ++++++++---
 .../X86/Sse2/ShiftRightLogical.Int32.1.cs     | 19 ++++++++---
 .../X86/Sse2/ShiftRightLogical.Int32.32.cs    | 19 ++++++++---
 .../X86/Sse2/ShiftRightLogical.Int64.1.cs     | 19 ++++++++---
 .../X86/Sse2/ShiftRightLogical.Int64.64.cs    | 19 ++++++++---
 .../X86/Sse2/ShiftRightLogical.UInt16.1.cs    | 19 ++++++++---
 .../X86/Sse2/ShiftRightLogical.UInt16.16.cs   | 19 ++++++++---
 .../X86/Sse2/ShiftRightLogical.UInt32.1.cs    | 19 ++++++++---
 .../X86/Sse2/ShiftRightLogical.UInt32.32.cs   | 19 ++++++++---
 .../X86/Sse2/ShiftRightLogical.UInt64.1.cs    | 19 ++++++++---
 .../X86/Sse2/ShiftRightLogical.UInt64.64.cs   | 19 ++++++++---
 .../ShiftRightLogical128BitLane.Byte.1.cs     | 19 ++++++++---
 .../ShiftRightLogical128BitLane.Int16.1.cs    | 19 ++++++++---
 .../ShiftRightLogical128BitLane.Int32.1.cs    | 19 ++++++++---
 .../ShiftRightLogical128BitLane.Int64.1.cs    | 19 ++++++++---
 .../ShiftRightLogical128BitLane.SByte.1.cs    | 19 ++++++++---
 .../ShiftRightLogical128BitLane.UInt16.1.cs   | 19 ++++++++---
 .../ShiftRightLogical128BitLane.UInt32.1.cs   | 19 ++++++++---
 .../ShiftRightLogical128BitLane.UInt64.1.cs   | 19 ++++++++---
 .../X86/Sse2/Subtract.Byte.cs                 | 19 ++++++++---
 .../X86/Sse2/Subtract.Double.cs               | 19 ++++++++---
 .../X86/Sse2/Subtract.Int16.cs                | 19 ++++++++---
 .../X86/Sse2/Subtract.Int32.cs                | 19 ++++++++---
 .../X86/Sse2/Subtract.Int64.cs                | 19 ++++++++---
 .../X86/Sse2/Subtract.SByte.cs                | 19 ++++++++---
 .../X86/Sse2/Subtract.UInt16.cs               | 19 ++++++++---
 .../X86/Sse2/Subtract.UInt32.cs               | 19 ++++++++---
 .../X86/Sse2/Subtract.UInt64.cs               | 19 ++++++++---
 .../X86/Sse2/SubtractSaturate.Byte.cs         | 19 ++++++++---
 .../X86/Sse2/SubtractSaturate.Int16.cs        | 19 ++++++++---
 .../X86/Sse2/SubtractSaturate.SByte.cs        | 19 ++++++++---
 .../X86/Sse2/SubtractSaturate.UInt16.cs       | 19 ++++++++---
 .../X86/Sse2/SubtractScalar.Double.cs         | 19 ++++++++---
 .../X86/Sse2/SumAbsoluteDifferences.UInt16.cs | 19 ++++++++---
 .../X86/Sse2/UnpackHigh.Byte.cs               | 19 ++++++++---
 .../X86/Sse2/UnpackHigh.Double.cs             | 19 ++++++++---
 .../X86/Sse2/UnpackHigh.Int16.cs              | 19 ++++++++---
 .../X86/Sse2/UnpackHigh.Int32.cs              | 19 ++++++++---
 .../X86/Sse2/UnpackHigh.Int64.cs              | 19 ++++++++---
 .../X86/Sse2/UnpackHigh.SByte.cs              | 19 ++++++++---
 .../X86/Sse2/UnpackHigh.UInt16.cs             | 19 ++++++++---
 .../X86/Sse2/UnpackHigh.UInt32.cs             | 19 ++++++++---
 .../X86/Sse2/UnpackHigh.UInt64.cs             | 19 ++++++++---
 .../X86/Sse2/UnpackLow.Byte.cs                | 19 ++++++++---
 .../X86/Sse2/UnpackLow.Double.cs              | 19 ++++++++---
 .../X86/Sse2/UnpackLow.Int16.cs               | 19 ++++++++---
 .../X86/Sse2/UnpackLow.Int32.cs               | 19 ++++++++---
 .../X86/Sse2/UnpackLow.Int64.cs               | 19 ++++++++---
 .../X86/Sse2/UnpackLow.SByte.cs               | 19 ++++++++---
 .../X86/Sse2/UnpackLow.UInt16.cs              | 19 ++++++++---
 .../X86/Sse2/UnpackLow.UInt32.cs              | 19 ++++++++---
 .../X86/Sse2/UnpackLow.UInt64.cs              | 19 ++++++++---
 .../HardwareIntrinsics/X86/Sse2/Xor.Byte.cs   | 19 ++++++++---
 .../HardwareIntrinsics/X86/Sse2/Xor.Double.cs | 19 ++++++++---
 .../HardwareIntrinsics/X86/Sse2/Xor.Int16.cs  | 19 ++++++++---
 .../HardwareIntrinsics/X86/Sse2/Xor.Int32.cs  | 19 ++++++++---
 .../HardwareIntrinsics/X86/Sse2/Xor.Int64.cs  | 19 ++++++++---
 .../HardwareIntrinsics/X86/Sse2/Xor.SByte.cs  | 19 ++++++++---
 .../HardwareIntrinsics/X86/Sse2/Xor.UInt16.cs | 19 ++++++++---
 .../HardwareIntrinsics/X86/Sse2/Xor.UInt32.cs | 19 ++++++++---
 .../HardwareIntrinsics/X86/Sse2/Xor.UInt64.cs | 19 ++++++++---
 .../X86/Sse3/AddSubtract.Double.cs            | 19 ++++++++---
 .../X86/Sse3/AddSubtract.Single.cs            | 19 ++++++++---
 .../X86/Sse3/HorizontalAdd.Double.cs          | 19 ++++++++---
 .../X86/Sse3/HorizontalAdd.Single.cs          | 19 ++++++++---
 .../X86/Sse3/HorizontalSubtract.Double.cs     | 19 ++++++++---
 .../X86/Sse3/HorizontalSubtract.Single.cs     | 19 ++++++++---
 .../X86/Sse41/BlendVariable.Byte.cs           | 19 ++++++++---
 .../X86/Sse41/BlendVariable.Double.cs         | 19 ++++++++---
 .../X86/Sse41/BlendVariable.Int16.cs          | 19 ++++++++---
 .../X86/Sse41/BlendVariable.Int32.cs          | 19 ++++++++---
 .../X86/Sse41/BlendVariable.Int64.cs          | 19 ++++++++---
 .../X86/Sse41/BlendVariable.SByte.cs          | 19 ++++++++---
 .../X86/Sse41/BlendVariable.Single.cs         | 19 ++++++++---
 .../X86/Sse41/BlendVariable.UInt16.cs         | 19 ++++++++---
 .../X86/Sse41/BlendVariable.UInt32.cs         | 19 ++++++++---
 .../X86/Sse41/BlendVariable.UInt64.cs         | 19 ++++++++---
 .../X86/Sse41/Ceiling.Double.cs               | 19 ++++++++---
 .../X86/Sse41/Ceiling.Single.cs               | 19 ++++++++---
 .../X86/Sse41/CeilingScalar.Double.cs         | 19 ++++++++---
 .../X86/Sse41/CeilingScalar.Single.cs         | 19 ++++++++---
 .../X86/Sse41/CompareEqual.Int64.cs           | 19 ++++++++---
 .../X86/Sse41/CompareEqual.UInt64.cs          | 19 ++++++++---
 .../X86/Sse41/Extract.Byte.1.cs               | 17 +++++++---
 .../X86/Sse41/Extract.Byte.129.cs             | 17 +++++++---
 .../X86/Sse41/Extract.Int32.1.cs              | 17 +++++++---
 .../X86/Sse41/Extract.Int32.129.cs            | 17 +++++++---
 .../X86/Sse41/Extract.Int64.1.cs              | 17 +++++++---
 .../X86/Sse41/Extract.Int64.129.cs            | 17 +++++++---
 .../X86/Sse41/Extract.Single.1.cs             | 17 +++++++---
 .../X86/Sse41/Extract.Single.129.cs           | 17 +++++++---
 .../X86/Sse41/Extract.UInt32.1.cs             | 17 +++++++---
 .../X86/Sse41/Extract.UInt32.129.cs           | 17 +++++++---
 .../X86/Sse41/Extract.UInt64.1.cs             | 17 +++++++---
 .../X86/Sse41/Extract.UInt64.129.cs           | 17 +++++++---
 .../X86/Sse41/Floor.Double.cs                 | 19 ++++++++---
 .../X86/Sse41/Floor.Single.cs                 | 19 ++++++++---
 .../X86/Sse41/FloorScalar.Double.cs           | 19 ++++++++---
 .../X86/Sse41/FloorScalar.Single.cs           | 19 ++++++++---
 .../X86/Sse41/Insert.Byte.1.cs                | 16 +++++++---
 .../X86/Sse41/Insert.Byte.129.cs              | 16 +++++++---
 .../X86/Sse41/Insert.Int32.1.cs               | 16 +++++++---
 .../X86/Sse41/Insert.Int32.129.cs             | 16 +++++++---
 .../X86/Sse41/Insert.Int64.1.cs               | 16 +++++++---
 .../X86/Sse41/Insert.Int64.129.cs             | 16 +++++++---
 .../X86/Sse41/Insert.SByte.1.cs               | 16 +++++++---
 .../X86/Sse41/Insert.SByte.129.cs             | 16 +++++++---
 .../X86/Sse41/Insert.Single.0.cs              | 19 ++++++++---
 .../X86/Sse41/Insert.Single.1.cs              | 19 ++++++++---
 .../X86/Sse41/Insert.Single.128.cs            | 19 ++++++++---
 .../X86/Sse41/Insert.Single.129.cs            | 19 ++++++++---
 .../X86/Sse41/Insert.Single.16.cs             | 19 ++++++++---
 .../X86/Sse41/Insert.Single.192.cs            | 19 ++++++++---
 .../X86/Sse41/Insert.Single.2.cs              | 19 ++++++++---
 .../X86/Sse41/Insert.Single.32.cs             | 19 ++++++++---
 .../X86/Sse41/Insert.Single.4.cs              | 19 ++++++++---
 .../X86/Sse41/Insert.Single.48.cs             | 19 ++++++++---
 .../X86/Sse41/Insert.Single.64.cs             | 19 ++++++++---
 .../X86/Sse41/Insert.Single.8.cs              | 19 ++++++++---
 .../X86/Sse41/Insert.UInt32.1.cs              | 16 +++++++---
 .../X86/Sse41/Insert.UInt32.129.cs            | 16 +++++++---
 .../X86/Sse41/Insert.UInt64.1.cs              | 16 +++++++---
 .../X86/Sse41/Insert.UInt64.129.cs            | 16 +++++++---
 .../HardwareIntrinsics/X86/Sse41/Max.Int32.cs | 19 ++++++++---
 .../HardwareIntrinsics/X86/Sse41/Max.SByte.cs | 19 ++++++++---
 .../X86/Sse41/Max.UInt16.cs                   | 19 ++++++++---
 .../X86/Sse41/Max.UInt32.cs                   | 19 ++++++++---
 .../HardwareIntrinsics/X86/Sse41/Min.Int32.cs | 19 ++++++++---
 .../HardwareIntrinsics/X86/Sse41/Min.SByte.cs | 19 ++++++++---
 .../X86/Sse41/Min.UInt16.cs                   | 19 ++++++++---
 .../X86/Sse41/Min.UInt32.cs                   | 19 ++++++++---
 .../X86/Sse41/MultiplyLow.Int32.cs            | 19 ++++++++---
 .../X86/Sse41/MultiplyLow.UInt32.cs           | 19 ++++++++---
 .../X86/Sse41/PackUnsignedSaturate.UInt16.cs  | 19 ++++++++---
 .../X86/Sse41/RoundCurrentDirection.Double.cs | 19 ++++++++---
 .../X86/Sse41/RoundCurrentDirection.Single.cs | 19 ++++++++---
 .../RoundCurrentDirectionScalar.Double.cs     | 19 ++++++++---
 .../RoundCurrentDirectionScalar.Single.cs     | 19 ++++++++---
 .../X86/Sse41/RoundToNearestInteger.Double.cs | 19 ++++++++---
 .../X86/Sse41/RoundToNearestInteger.Single.cs | 19 ++++++++---
 .../RoundToNearestIntegerScalar.Double.cs     | 19 ++++++++---
 .../RoundToNearestIntegerScalar.Single.cs     | 19 ++++++++---
 .../Sse41/RoundToNegativeInfinity.Double.cs   | 19 ++++++++---
 .../Sse41/RoundToNegativeInfinity.Single.cs   | 19 ++++++++---
 .../RoundToNegativeInfinityScalar.Double.cs   | 19 ++++++++---
 .../RoundToNegativeInfinityScalar.Single.cs   | 19 ++++++++---
 .../Sse41/RoundToPositiveInfinity.Double.cs   | 19 ++++++++---
 .../Sse41/RoundToPositiveInfinity.Single.cs   | 19 ++++++++---
 .../RoundToPositiveInfinityScalar.Double.cs   | 19 ++++++++---
 .../RoundToPositiveInfinityScalar.Single.cs   | 19 ++++++++---
 .../X86/Sse41/RoundToZero.Double.cs           | 19 ++++++++---
 .../X86/Sse41/RoundToZero.Single.cs           | 19 ++++++++---
 .../X86/Sse41/RoundToZeroScalar.Double.cs     | 19 ++++++++---
 .../X86/Sse41/RoundToZeroScalar.Single.cs     | 19 ++++++++---
 .../X86/Sse41/TestAllOnes.Byte.cs             | 13 +++++---
 .../X86/Sse41/TestAllOnes.Int16.cs            | 13 +++++---
 .../X86/Sse41/TestAllOnes.Int32.cs            | 13 +++++---
 .../X86/Sse41/TestAllOnes.Int64.cs            | 13 +++++---
 .../X86/Sse41/TestAllOnes.SByte.cs            | 13 +++++---
 .../X86/Sse41/TestAllOnes.UInt16.cs           | 13 +++++---
 .../X86/Sse41/TestAllOnes.UInt32.cs           | 13 +++++---
 .../X86/Sse41/TestAllOnes.UInt64.cs           | 13 +++++---
 .../X86/Sse41/TestAllZeros.Byte.cs            | 13 +++++---
 .../X86/Sse41/TestAllZeros.Int16.cs           | 13 +++++---
 .../X86/Sse41/TestAllZeros.Int32.cs           | 13 +++++---
 .../X86/Sse41/TestAllZeros.Int64.cs           | 13 +++++---
 .../X86/Sse41/TestAllZeros.SByte.cs           | 13 +++++---
 .../X86/Sse41/TestAllZeros.UInt16.cs          | 13 +++++---
 .../X86/Sse41/TestAllZeros.UInt32.cs          | 13 +++++---
 .../X86/Sse41/TestAllZeros.UInt64.cs          | 13 +++++---
 .../X86/Sse41/TestC.Byte.cs                   | 13 +++++---
 .../X86/Sse41/TestC.Int16.cs                  | 13 +++++---
 .../X86/Sse41/TestC.Int32.cs                  | 13 +++++---
 .../X86/Sse41/TestC.Int64.cs                  | 13 +++++---
 .../X86/Sse41/TestC.SByte.cs                  | 13 +++++---
 .../X86/Sse41/TestC.UInt16.cs                 | 13 +++++---
 .../X86/Sse41/TestC.UInt32.cs                 | 13 +++++---
 .../X86/Sse41/TestC.UInt64.cs                 | 13 +++++---
 .../X86/Sse41/TestMixOnesZeros.Byte.cs        | 13 +++++---
 .../X86/Sse41/TestMixOnesZeros.Int16.cs       | 13 +++++---
 .../X86/Sse41/TestMixOnesZeros.Int32.cs       | 13 +++++---
 .../X86/Sse41/TestMixOnesZeros.Int64.cs       | 13 +++++---
 .../X86/Sse41/TestMixOnesZeros.SByte.cs       | 13 +++++---
 .../X86/Sse41/TestMixOnesZeros.UInt16.cs      | 13 +++++---
 .../X86/Sse41/TestMixOnesZeros.UInt32.cs      | 13 +++++---
 .../X86/Sse41/TestMixOnesZeros.UInt64.cs      | 13 +++++---
 .../X86/Sse41/TestNotZAndNotC.Byte.cs         | 13 +++++---
 .../X86/Sse41/TestNotZAndNotC.Int16.cs        | 13 +++++---
 .../X86/Sse41/TestNotZAndNotC.Int32.cs        | 13 +++++---
 .../X86/Sse41/TestNotZAndNotC.Int64.cs        | 13 +++++---
 .../X86/Sse41/TestNotZAndNotC.SByte.cs        | 13 +++++---
 .../X86/Sse41/TestNotZAndNotC.UInt16.cs       | 13 +++++---
 .../X86/Sse41/TestNotZAndNotC.UInt32.cs       | 13 +++++---
 .../X86/Sse41/TestNotZAndNotC.UInt64.cs       | 13 +++++---
 .../X86/Sse41/TestZ.Byte.cs                   | 13 +++++---
 .../X86/Sse41/TestZ.Int16.cs                  | 13 +++++---
 .../X86/Sse41/TestZ.Int32.cs                  | 13 +++++---
 .../X86/Sse41/TestZ.Int64.cs                  | 13 +++++---
 .../X86/Sse41/TestZ.SByte.cs                  | 13 +++++---
 .../X86/Sse41/TestZ.UInt16.cs                 | 13 +++++---
 .../X86/Sse41/TestZ.UInt32.cs                 | 13 +++++---
 .../X86/Sse41/TestZ.UInt64.cs                 | 13 +++++---
 .../X86/Sse42/CompareGreaterThan.Int64.cs     | 19 ++++++++---
 .../HardwareIntrinsics/X86/Ssse3/Abs.Byte.cs  | 19 ++++++++---
 .../X86/Ssse3/Abs.UInt16.cs                   | 19 ++++++++---
 .../X86/Ssse3/Abs.UInt32.cs                   | 19 ++++++++---
 .../X86/Ssse3/AlignRight.Byte.0.cs            | 19 ++++++++---
 .../X86/Ssse3/AlignRight.Byte.1.cs            | 19 ++++++++---
 .../X86/Ssse3/AlignRight.Int16.0.cs           | 19 ++++++++---
 .../X86/Ssse3/AlignRight.Int16.2.cs           | 19 ++++++++---
 .../X86/Ssse3/AlignRight.Int32.0.cs           | 19 ++++++++---
 .../X86/Ssse3/AlignRight.Int32.4.cs           | 19 ++++++++---
 .../X86/Ssse3/AlignRight.Int64.0.cs           | 19 ++++++++---
 .../X86/Ssse3/AlignRight.Int64.8.cs           | 19 ++++++++---
 .../X86/Ssse3/AlignRight.SByte.0.cs           | 19 ++++++++---
 .../X86/Ssse3/AlignRight.SByte.1.cs           | 19 ++++++++---
 .../X86/Ssse3/AlignRight.UInt16.0.cs          | 19 ++++++++---
 .../X86/Ssse3/AlignRight.UInt16.2.cs          | 19 ++++++++---
 .../X86/Ssse3/AlignRight.UInt32.0.cs          | 19 ++++++++---
 .../X86/Ssse3/AlignRight.UInt32.4.cs          | 19 ++++++++---
 .../X86/Ssse3/AlignRight.UInt64.0.cs          | 19 ++++++++---
 .../X86/Ssse3/AlignRight.UInt64.8.cs          | 19 ++++++++---
 .../X86/Ssse3/HorizontalAdd.Int16.cs          | 19 ++++++++---
 .../X86/Ssse3/HorizontalAdd.Int32.cs          | 19 ++++++++---
 .../X86/Ssse3/HorizontalAddSaturate.Int16.cs  | 19 ++++++++---
 .../X86/Ssse3/HorizontalSubtract.Int16.cs     | 19 ++++++++---
 .../X86/Ssse3/HorizontalSubtract.Int32.cs     | 19 ++++++++---
 .../Ssse3/HorizontalSubtractSaturate.Int16.cs | 19 ++++++++---
 .../X86/Ssse3/MultiplyAddAdjacent.Int16.cs    | 19 ++++++++---
 .../X86/Ssse3/MultiplyHighRoundScale.Int16.cs | 19 ++++++++---
 .../X86/Ssse3/Shuffle.Byte.cs                 | 19 ++++++++---
 .../X86/Ssse3/Shuffle.SByte.cs                | 19 ++++++++---
 .../X86/Ssse3/Sign.Int16.cs                   | 19 ++++++++---
 .../X86/Ssse3/Sign.Int32.cs                   | 19 ++++++++---
 .../X86/Ssse3/Sign.SByte.cs                   | 19 ++++++++---
 1430 files changed, 15896 insertions(+), 6168 deletions(-)

diff --git a/tests/src/JIT/HardwareIntrinsics/General/NotSupported/Vector128BooleanAsByte.cs b/tests/src/JIT/HardwareIntrinsics/General/NotSupported/Vector128BooleanAsByte.cs
index d02c6332ec50..aca455e75d94 100644
--- a/tests/src/JIT/HardwareIntrinsics/General/NotSupported/Vector128BooleanAsByte.cs
+++ b/tests/src/JIT/HardwareIntrinsics/General/NotSupported/Vector128BooleanAsByte.cs
@@ -35,6 +35,8 @@ private static void Vector128BooleanAsByte()
             {
                 TestLibrary.TestFramework.LogInformation($"Vector128BooleanAsByte: RunNotSupportedScenario failed to throw NotSupportedException.");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                throw new Exception("One or more scenarios did not complete as expected.");
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/General/NotSupported/Vector128BooleanAsDouble.cs b/tests/src/JIT/HardwareIntrinsics/General/NotSupported/Vector128BooleanAsDouble.cs
index 5ad235bffeb3..e6630fb904c9 100644
--- a/tests/src/JIT/HardwareIntrinsics/General/NotSupported/Vector128BooleanAsDouble.cs
+++ b/tests/src/JIT/HardwareIntrinsics/General/NotSupported/Vector128BooleanAsDouble.cs
@@ -35,6 +35,8 @@ private static void Vector128BooleanAsDouble()
             {
                 TestLibrary.TestFramework.LogInformation($"Vector128BooleanAsDouble: RunNotSupportedScenario failed to throw NotSupportedException.");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                throw new Exception("One or more scenarios did not complete as expected.");
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/General/NotSupported/Vector128BooleanAsGeneric_Boolean.cs b/tests/src/JIT/HardwareIntrinsics/General/NotSupported/Vector128BooleanAsGeneric_Boolean.cs
index d60ce57d4a23..96ad8dc4bbad 100644
--- a/tests/src/JIT/HardwareIntrinsics/General/NotSupported/Vector128BooleanAsGeneric_Boolean.cs
+++ b/tests/src/JIT/HardwareIntrinsics/General/NotSupported/Vector128BooleanAsGeneric_Boolean.cs
@@ -35,6 +35,8 @@ private static void Vector128BooleanAsGeneric_Boolean()
             {
                 TestLibrary.TestFramework.LogInformation($"Vector128BooleanAsGeneric_Boolean: RunNotSupportedScenario failed to throw NotSupportedException.");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                throw new Exception("One or more scenarios did not complete as expected.");
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/General/NotSupported/Vector128BooleanAsGeneric_Byte.cs b/tests/src/JIT/HardwareIntrinsics/General/NotSupported/Vector128BooleanAsGeneric_Byte.cs
index 0ad3fc3ed4bd..9bc250f7b25b 100644
--- a/tests/src/JIT/HardwareIntrinsics/General/NotSupported/Vector128BooleanAsGeneric_Byte.cs
+++ b/tests/src/JIT/HardwareIntrinsics/General/NotSupported/Vector128BooleanAsGeneric_Byte.cs
@@ -35,6 +35,8 @@ private static void Vector128BooleanAsGeneric_Byte()
             {
                 TestLibrary.TestFramework.LogInformation($"Vector128BooleanAsGeneric_Byte: RunNotSupportedScenario failed to throw NotSupportedException.");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                throw new Exception("One or more scenarios did not complete as expected.");
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/General/NotSupported/Vector128BooleanAsGeneric_Double.cs b/tests/src/JIT/HardwareIntrinsics/General/NotSupported/Vector128BooleanAsGeneric_Double.cs
index 002a165c238d..60ee34aa8358 100644
--- a/tests/src/JIT/HardwareIntrinsics/General/NotSupported/Vector128BooleanAsGeneric_Double.cs
+++ b/tests/src/JIT/HardwareIntrinsics/General/NotSupported/Vector128BooleanAsGeneric_Double.cs
@@ -35,6 +35,8 @@ private static void Vector128BooleanAsGeneric_Double()
             {
                 TestLibrary.TestFramework.LogInformation($"Vector128BooleanAsGeneric_Double: RunNotSupportedScenario failed to throw NotSupportedException.");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                throw new Exception("One or more scenarios did not complete as expected.");
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/General/NotSupported/Vector128BooleanAsGeneric_Int16.cs b/tests/src/JIT/HardwareIntrinsics/General/NotSupported/Vector128BooleanAsGeneric_Int16.cs
index 5276a9877a4a..7f0994b2ba52 100644
--- a/tests/src/JIT/HardwareIntrinsics/General/NotSupported/Vector128BooleanAsGeneric_Int16.cs
+++ b/tests/src/JIT/HardwareIntrinsics/General/NotSupported/Vector128BooleanAsGeneric_Int16.cs
@@ -35,6 +35,8 @@ private static void Vector128BooleanAsGeneric_Int16()
             {
                 TestLibrary.TestFramework.LogInformation($"Vector128BooleanAsGeneric_Int16: RunNotSupportedScenario failed to throw NotSupportedException.");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                throw new Exception("One or more scenarios did not complete as expected.");
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/General/NotSupported/Vector128BooleanAsGeneric_Int32.cs b/tests/src/JIT/HardwareIntrinsics/General/NotSupported/Vector128BooleanAsGeneric_Int32.cs
index 835f9daa026d..b376e29b5c43 100644
--- a/tests/src/JIT/HardwareIntrinsics/General/NotSupported/Vector128BooleanAsGeneric_Int32.cs
+++ b/tests/src/JIT/HardwareIntrinsics/General/NotSupported/Vector128BooleanAsGeneric_Int32.cs
@@ -35,6 +35,8 @@ private static void Vector128BooleanAsGeneric_Int32()
             {
                 TestLibrary.TestFramework.LogInformation($"Vector128BooleanAsGeneric_Int32: RunNotSupportedScenario failed to throw NotSupportedException.");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                throw new Exception("One or more scenarios did not complete as expected.");
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/General/NotSupported/Vector128BooleanAsGeneric_Int64.cs b/tests/src/JIT/HardwareIntrinsics/General/NotSupported/Vector128BooleanAsGeneric_Int64.cs
index 330ad2b08a1d..cca97521d267 100644
--- a/tests/src/JIT/HardwareIntrinsics/General/NotSupported/Vector128BooleanAsGeneric_Int64.cs
+++ b/tests/src/JIT/HardwareIntrinsics/General/NotSupported/Vector128BooleanAsGeneric_Int64.cs
@@ -35,6 +35,8 @@ private static void Vector128BooleanAsGeneric_Int64()
             {
                 TestLibrary.TestFramework.LogInformation($"Vector128BooleanAsGeneric_Int64: RunNotSupportedScenario failed to throw NotSupportedException.");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                throw new Exception("One or more scenarios did not complete as expected.");
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/General/NotSupported/Vector128BooleanAsGeneric_SByte.cs b/tests/src/JIT/HardwareIntrinsics/General/NotSupported/Vector128BooleanAsGeneric_SByte.cs
index 84a9fc9c7ce4..31aae0864284 100644
--- a/tests/src/JIT/HardwareIntrinsics/General/NotSupported/Vector128BooleanAsGeneric_SByte.cs
+++ b/tests/src/JIT/HardwareIntrinsics/General/NotSupported/Vector128BooleanAsGeneric_SByte.cs
@@ -35,6 +35,8 @@ private static void Vector128BooleanAsGeneric_SByte()
             {
                 TestLibrary.TestFramework.LogInformation($"Vector128BooleanAsGeneric_SByte: RunNotSupportedScenario failed to throw NotSupportedException.");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                throw new Exception("One or more scenarios did not complete as expected.");
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/General/NotSupported/Vector128BooleanAsGeneric_Single.cs b/tests/src/JIT/HardwareIntrinsics/General/NotSupported/Vector128BooleanAsGeneric_Single.cs
index 801b4959054a..c5243734ccfc 100644
--- a/tests/src/JIT/HardwareIntrinsics/General/NotSupported/Vector128BooleanAsGeneric_Single.cs
+++ b/tests/src/JIT/HardwareIntrinsics/General/NotSupported/Vector128BooleanAsGeneric_Single.cs
@@ -35,6 +35,8 @@ private static void Vector128BooleanAsGeneric_Single()
             {
                 TestLibrary.TestFramework.LogInformation($"Vector128BooleanAsGeneric_Single: RunNotSupportedScenario failed to throw NotSupportedException.");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                throw new Exception("One or more scenarios did not complete as expected.");
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/General/NotSupported/Vector128BooleanAsGeneric_UInt16.cs b/tests/src/JIT/HardwareIntrinsics/General/NotSupported/Vector128BooleanAsGeneric_UInt16.cs
index f592bde98ea7..a6bd952e4293 100644
--- a/tests/src/JIT/HardwareIntrinsics/General/NotSupported/Vector128BooleanAsGeneric_UInt16.cs
+++ b/tests/src/JIT/HardwareIntrinsics/General/NotSupported/Vector128BooleanAsGeneric_UInt16.cs
@@ -35,6 +35,8 @@ private static void Vector128BooleanAsGeneric_UInt16()
             {
                 TestLibrary.TestFramework.LogInformation($"Vector128BooleanAsGeneric_UInt16: RunNotSupportedScenario failed to throw NotSupportedException.");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                throw new Exception("One or more scenarios did not complete as expected.");
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/General/NotSupported/Vector128BooleanAsGeneric_UInt32.cs b/tests/src/JIT/HardwareIntrinsics/General/NotSupported/Vector128BooleanAsGeneric_UInt32.cs
index 8aa5b5b5ce96..b9598753a953 100644
--- a/tests/src/JIT/HardwareIntrinsics/General/NotSupported/Vector128BooleanAsGeneric_UInt32.cs
+++ b/tests/src/JIT/HardwareIntrinsics/General/NotSupported/Vector128BooleanAsGeneric_UInt32.cs
@@ -35,6 +35,8 @@ private static void Vector128BooleanAsGeneric_UInt32()
             {
                 TestLibrary.TestFramework.LogInformation($"Vector128BooleanAsGeneric_UInt32: RunNotSupportedScenario failed to throw NotSupportedException.");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                throw new Exception("One or more scenarios did not complete as expected.");
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/General/NotSupported/Vector128BooleanAsGeneric_UInt64.cs b/tests/src/JIT/HardwareIntrinsics/General/NotSupported/Vector128BooleanAsGeneric_UInt64.cs
index a4294f3848ed..ec09a5a2223f 100644
--- a/tests/src/JIT/HardwareIntrinsics/General/NotSupported/Vector128BooleanAsGeneric_UInt64.cs
+++ b/tests/src/JIT/HardwareIntrinsics/General/NotSupported/Vector128BooleanAsGeneric_UInt64.cs
@@ -35,6 +35,8 @@ private static void Vector128BooleanAsGeneric_UInt64()
             {
                 TestLibrary.TestFramework.LogInformation($"Vector128BooleanAsGeneric_UInt64: RunNotSupportedScenario failed to throw NotSupportedException.");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                throw new Exception("One or more scenarios did not complete as expected.");
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/General/NotSupported/Vector128BooleanAsInt16.cs b/tests/src/JIT/HardwareIntrinsics/General/NotSupported/Vector128BooleanAsInt16.cs
index b34aa76e96b9..45f6d19a0cbd 100644
--- a/tests/src/JIT/HardwareIntrinsics/General/NotSupported/Vector128BooleanAsInt16.cs
+++ b/tests/src/JIT/HardwareIntrinsics/General/NotSupported/Vector128BooleanAsInt16.cs
@@ -35,6 +35,8 @@ private static void Vector128BooleanAsInt16()
             {
                 TestLibrary.TestFramework.LogInformation($"Vector128BooleanAsInt16: RunNotSupportedScenario failed to throw NotSupportedException.");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                throw new Exception("One or more scenarios did not complete as expected.");
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/General/NotSupported/Vector128BooleanAsInt32.cs b/tests/src/JIT/HardwareIntrinsics/General/NotSupported/Vector128BooleanAsInt32.cs
index 352c79a03ce5..aafbf9200b66 100644
--- a/tests/src/JIT/HardwareIntrinsics/General/NotSupported/Vector128BooleanAsInt32.cs
+++ b/tests/src/JIT/HardwareIntrinsics/General/NotSupported/Vector128BooleanAsInt32.cs
@@ -35,6 +35,8 @@ private static void Vector128BooleanAsInt32()
             {
                 TestLibrary.TestFramework.LogInformation($"Vector128BooleanAsInt32: RunNotSupportedScenario failed to throw NotSupportedException.");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                throw new Exception("One or more scenarios did not complete as expected.");
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/General/NotSupported/Vector128BooleanAsInt64.cs b/tests/src/JIT/HardwareIntrinsics/General/NotSupported/Vector128BooleanAsInt64.cs
index aae7077bb332..dc571b7b993c 100644
--- a/tests/src/JIT/HardwareIntrinsics/General/NotSupported/Vector128BooleanAsInt64.cs
+++ b/tests/src/JIT/HardwareIntrinsics/General/NotSupported/Vector128BooleanAsInt64.cs
@@ -35,6 +35,8 @@ private static void Vector128BooleanAsInt64()
             {
                 TestLibrary.TestFramework.LogInformation($"Vector128BooleanAsInt64: RunNotSupportedScenario failed to throw NotSupportedException.");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                throw new Exception("One or more scenarios did not complete as expected.");
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/General/NotSupported/Vector128BooleanAsSByte.cs b/tests/src/JIT/HardwareIntrinsics/General/NotSupported/Vector128BooleanAsSByte.cs
index 3d9047826934..bb106b4e2117 100644
--- a/tests/src/JIT/HardwareIntrinsics/General/NotSupported/Vector128BooleanAsSByte.cs
+++ b/tests/src/JIT/HardwareIntrinsics/General/NotSupported/Vector128BooleanAsSByte.cs
@@ -35,6 +35,8 @@ private static void Vector128BooleanAsSByte()
             {
                 TestLibrary.TestFramework.LogInformation($"Vector128BooleanAsSByte: RunNotSupportedScenario failed to throw NotSupportedException.");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                throw new Exception("One or more scenarios did not complete as expected.");
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/General/NotSupported/Vector128BooleanAsSingle.cs b/tests/src/JIT/HardwareIntrinsics/General/NotSupported/Vector128BooleanAsSingle.cs
index a8d11652b287..6372bd16a568 100644
--- a/tests/src/JIT/HardwareIntrinsics/General/NotSupported/Vector128BooleanAsSingle.cs
+++ b/tests/src/JIT/HardwareIntrinsics/General/NotSupported/Vector128BooleanAsSingle.cs
@@ -35,6 +35,8 @@ private static void Vector128BooleanAsSingle()
             {
                 TestLibrary.TestFramework.LogInformation($"Vector128BooleanAsSingle: RunNotSupportedScenario failed to throw NotSupportedException.");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                throw new Exception("One or more scenarios did not complete as expected.");
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/General/NotSupported/Vector128BooleanAsUInt16.cs b/tests/src/JIT/HardwareIntrinsics/General/NotSupported/Vector128BooleanAsUInt16.cs
index 0038536ba408..854e346a714b 100644
--- a/tests/src/JIT/HardwareIntrinsics/General/NotSupported/Vector128BooleanAsUInt16.cs
+++ b/tests/src/JIT/HardwareIntrinsics/General/NotSupported/Vector128BooleanAsUInt16.cs
@@ -35,6 +35,8 @@ private static void Vector128BooleanAsUInt16()
             {
                 TestLibrary.TestFramework.LogInformation($"Vector128BooleanAsUInt16: RunNotSupportedScenario failed to throw NotSupportedException.");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                throw new Exception("One or more scenarios did not complete as expected.");
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/General/NotSupported/Vector128BooleanAsUInt32.cs b/tests/src/JIT/HardwareIntrinsics/General/NotSupported/Vector128BooleanAsUInt32.cs
index 8769bd42a670..0dc51a9c7488 100644
--- a/tests/src/JIT/HardwareIntrinsics/General/NotSupported/Vector128BooleanAsUInt32.cs
+++ b/tests/src/JIT/HardwareIntrinsics/General/NotSupported/Vector128BooleanAsUInt32.cs
@@ -35,6 +35,8 @@ private static void Vector128BooleanAsUInt32()
             {
                 TestLibrary.TestFramework.LogInformation($"Vector128BooleanAsUInt32: RunNotSupportedScenario failed to throw NotSupportedException.");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                throw new Exception("One or more scenarios did not complete as expected.");
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/General/NotSupported/Vector128BooleanAsUInt64.cs b/tests/src/JIT/HardwareIntrinsics/General/NotSupported/Vector128BooleanAsUInt64.cs
index 5f720793d2f1..65384a72963d 100644
--- a/tests/src/JIT/HardwareIntrinsics/General/NotSupported/Vector128BooleanAsUInt64.cs
+++ b/tests/src/JIT/HardwareIntrinsics/General/NotSupported/Vector128BooleanAsUInt64.cs
@@ -35,6 +35,8 @@ private static void Vector128BooleanAsUInt64()
             {
                 TestLibrary.TestFramework.LogInformation($"Vector128BooleanAsUInt64: RunNotSupportedScenario failed to throw NotSupportedException.");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                throw new Exception("One or more scenarios did not complete as expected.");
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/General/NotSupported/Vector128ByteAsGeneric_Boolean.cs b/tests/src/JIT/HardwareIntrinsics/General/NotSupported/Vector128ByteAsGeneric_Boolean.cs
index 1b1ac5db935f..98ed33252861 100644
--- a/tests/src/JIT/HardwareIntrinsics/General/NotSupported/Vector128ByteAsGeneric_Boolean.cs
+++ b/tests/src/JIT/HardwareIntrinsics/General/NotSupported/Vector128ByteAsGeneric_Boolean.cs
@@ -35,6 +35,8 @@ private static void Vector128ByteAsGeneric_Boolean()
             {
                 TestLibrary.TestFramework.LogInformation($"Vector128ByteAsGeneric_Boolean: RunNotSupportedScenario failed to throw NotSupportedException.");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                throw new Exception("One or more scenarios did not complete as expected.");
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/General/NotSupported/Vector128DoubleAsGeneric_Boolean.cs b/tests/src/JIT/HardwareIntrinsics/General/NotSupported/Vector128DoubleAsGeneric_Boolean.cs
index 0422f59c2f3c..af2cf978a659 100644
--- a/tests/src/JIT/HardwareIntrinsics/General/NotSupported/Vector128DoubleAsGeneric_Boolean.cs
+++ b/tests/src/JIT/HardwareIntrinsics/General/NotSupported/Vector128DoubleAsGeneric_Boolean.cs
@@ -35,6 +35,8 @@ private static void Vector128DoubleAsGeneric_Boolean()
             {
                 TestLibrary.TestFramework.LogInformation($"Vector128DoubleAsGeneric_Boolean: RunNotSupportedScenario failed to throw NotSupportedException.");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                throw new Exception("One or more scenarios did not complete as expected.");
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/General/NotSupported/Vector128GetElement0.cs b/tests/src/JIT/HardwareIntrinsics/General/NotSupported/Vector128GetElement0.cs
index 8ee13cb26ed0..38ed45eeec29 100644
--- a/tests/src/JIT/HardwareIntrinsics/General/NotSupported/Vector128GetElement0.cs
+++ b/tests/src/JIT/HardwareIntrinsics/General/NotSupported/Vector128GetElement0.cs
@@ -35,6 +35,8 @@ private static void Vector128GetElement0()
             {
                 TestLibrary.TestFramework.LogInformation($"Vector128GetElement0: RunNotSupportedScenario failed to throw NotSupportedException.");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                throw new Exception("One or more scenarios did not complete as expected.");
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/General/NotSupported/Vector128GetElementMaxValue.cs b/tests/src/JIT/HardwareIntrinsics/General/NotSupported/Vector128GetElementMaxValue.cs
index 722c06af190a..805ad1fb2e02 100644
--- a/tests/src/JIT/HardwareIntrinsics/General/NotSupported/Vector128GetElementMaxValue.cs
+++ b/tests/src/JIT/HardwareIntrinsics/General/NotSupported/Vector128GetElementMaxValue.cs
@@ -35,6 +35,8 @@ private static void Vector128GetElementMaxValue()
             {
                 TestLibrary.TestFramework.LogInformation($"Vector128GetElementMaxValue: RunNotSupportedScenario failed to throw NotSupportedException.");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                throw new Exception("One or more scenarios did not complete as expected.");
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/General/NotSupported/Vector128GetElementNegativeOne.cs b/tests/src/JIT/HardwareIntrinsics/General/NotSupported/Vector128GetElementNegativeOne.cs
index b7eb97877784..65f80a404986 100644
--- a/tests/src/JIT/HardwareIntrinsics/General/NotSupported/Vector128GetElementNegativeOne.cs
+++ b/tests/src/JIT/HardwareIntrinsics/General/NotSupported/Vector128GetElementNegativeOne.cs
@@ -35,6 +35,8 @@ private static void Vector128GetElementNegativeOne()
             {
                 TestLibrary.TestFramework.LogInformation($"Vector128GetElementNegativeOne: RunNotSupportedScenario failed to throw NotSupportedException.");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                throw new Exception("One or more scenarios did not complete as expected.");
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/General/NotSupported/Vector128GetLower.cs b/tests/src/JIT/HardwareIntrinsics/General/NotSupported/Vector128GetLower.cs
index 18db9c9d50ba..6a04ad74d117 100644
--- a/tests/src/JIT/HardwareIntrinsics/General/NotSupported/Vector128GetLower.cs
+++ b/tests/src/JIT/HardwareIntrinsics/General/NotSupported/Vector128GetLower.cs
@@ -35,6 +35,8 @@ private static void Vector128GetLower()
             {
                 TestLibrary.TestFramework.LogInformation($"Vector128GetLower: RunNotSupportedScenario failed to throw NotSupportedException.");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                throw new Exception("One or more scenarios did not complete as expected.");
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/General/NotSupported/Vector128GetUpper.cs b/tests/src/JIT/HardwareIntrinsics/General/NotSupported/Vector128GetUpper.cs
index 32069261c313..9853318359c4 100644
--- a/tests/src/JIT/HardwareIntrinsics/General/NotSupported/Vector128GetUpper.cs
+++ b/tests/src/JIT/HardwareIntrinsics/General/NotSupported/Vector128GetUpper.cs
@@ -35,6 +35,8 @@ private static void Vector128GetUpper()
             {
                 TestLibrary.TestFramework.LogInformation($"Vector128GetUpper: RunNotSupportedScenario failed to throw NotSupportedException.");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                throw new Exception("One or more scenarios did not complete as expected.");
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/General/NotSupported/Vector128Int16AsGeneric_Boolean.cs b/tests/src/JIT/HardwareIntrinsics/General/NotSupported/Vector128Int16AsGeneric_Boolean.cs
index 495533b84a51..d81c68e51e92 100644
--- a/tests/src/JIT/HardwareIntrinsics/General/NotSupported/Vector128Int16AsGeneric_Boolean.cs
+++ b/tests/src/JIT/HardwareIntrinsics/General/NotSupported/Vector128Int16AsGeneric_Boolean.cs
@@ -35,6 +35,8 @@ private static void Vector128Int16AsGeneric_Boolean()
             {
                 TestLibrary.TestFramework.LogInformation($"Vector128Int16AsGeneric_Boolean: RunNotSupportedScenario failed to throw NotSupportedException.");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                throw new Exception("One or more scenarios did not complete as expected.");
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/General/NotSupported/Vector128Int32AsGeneric_Boolean.cs b/tests/src/JIT/HardwareIntrinsics/General/NotSupported/Vector128Int32AsGeneric_Boolean.cs
index 319677c62698..bf36df686e41 100644
--- a/tests/src/JIT/HardwareIntrinsics/General/NotSupported/Vector128Int32AsGeneric_Boolean.cs
+++ b/tests/src/JIT/HardwareIntrinsics/General/NotSupported/Vector128Int32AsGeneric_Boolean.cs
@@ -35,6 +35,8 @@ private static void Vector128Int32AsGeneric_Boolean()
             {
                 TestLibrary.TestFramework.LogInformation($"Vector128Int32AsGeneric_Boolean: RunNotSupportedScenario failed to throw NotSupportedException.");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                throw new Exception("One or more scenarios did not complete as expected.");
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/General/NotSupported/Vector128Int64AsGeneric_Boolean.cs b/tests/src/JIT/HardwareIntrinsics/General/NotSupported/Vector128Int64AsGeneric_Boolean.cs
index b3de12a5093e..cae020d3afb4 100644
--- a/tests/src/JIT/HardwareIntrinsics/General/NotSupported/Vector128Int64AsGeneric_Boolean.cs
+++ b/tests/src/JIT/HardwareIntrinsics/General/NotSupported/Vector128Int64AsGeneric_Boolean.cs
@@ -35,6 +35,8 @@ private static void Vector128Int64AsGeneric_Boolean()
             {
                 TestLibrary.TestFramework.LogInformation($"Vector128Int64AsGeneric_Boolean: RunNotSupportedScenario failed to throw NotSupportedException.");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                throw new Exception("One or more scenarios did not complete as expected.");
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/General/NotSupported/Vector128SByteAsGeneric_Boolean.cs b/tests/src/JIT/HardwareIntrinsics/General/NotSupported/Vector128SByteAsGeneric_Boolean.cs
index a6746e45273f..5f809eb9fd38 100644
--- a/tests/src/JIT/HardwareIntrinsics/General/NotSupported/Vector128SByteAsGeneric_Boolean.cs
+++ b/tests/src/JIT/HardwareIntrinsics/General/NotSupported/Vector128SByteAsGeneric_Boolean.cs
@@ -35,6 +35,8 @@ private static void Vector128SByteAsGeneric_Boolean()
             {
                 TestLibrary.TestFramework.LogInformation($"Vector128SByteAsGeneric_Boolean: RunNotSupportedScenario failed to throw NotSupportedException.");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                throw new Exception("One or more scenarios did not complete as expected.");
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/General/NotSupported/Vector128SingleAsGeneric_Boolean.cs b/tests/src/JIT/HardwareIntrinsics/General/NotSupported/Vector128SingleAsGeneric_Boolean.cs
index ef9a4a9095a0..a95b35184259 100644
--- a/tests/src/JIT/HardwareIntrinsics/General/NotSupported/Vector128SingleAsGeneric_Boolean.cs
+++ b/tests/src/JIT/HardwareIntrinsics/General/NotSupported/Vector128SingleAsGeneric_Boolean.cs
@@ -35,6 +35,8 @@ private static void Vector128SingleAsGeneric_Boolean()
             {
                 TestLibrary.TestFramework.LogInformation($"Vector128SingleAsGeneric_Boolean: RunNotSupportedScenario failed to throw NotSupportedException.");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                throw new Exception("One or more scenarios did not complete as expected.");
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/General/NotSupported/Vector128ToScalar.cs b/tests/src/JIT/HardwareIntrinsics/General/NotSupported/Vector128ToScalar.cs
index cf7f29a13126..55223d94929d 100644
--- a/tests/src/JIT/HardwareIntrinsics/General/NotSupported/Vector128ToScalar.cs
+++ b/tests/src/JIT/HardwareIntrinsics/General/NotSupported/Vector128ToScalar.cs
@@ -35,6 +35,8 @@ private static void Vector128ToScalar()
             {
                 TestLibrary.TestFramework.LogInformation($"Vector128ToScalar: RunNotSupportedScenario failed to throw NotSupportedException.");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                throw new Exception("One or more scenarios did not complete as expected.");
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/General/NotSupported/Vector128ToVector256.cs b/tests/src/JIT/HardwareIntrinsics/General/NotSupported/Vector128ToVector256.cs
index 1431045c5e37..4954fa678dd1 100644
--- a/tests/src/JIT/HardwareIntrinsics/General/NotSupported/Vector128ToVector256.cs
+++ b/tests/src/JIT/HardwareIntrinsics/General/NotSupported/Vector128ToVector256.cs
@@ -35,6 +35,8 @@ private static void Vector128ToVector256()
             {
                 TestLibrary.TestFramework.LogInformation($"Vector128ToVector256: RunNotSupportedScenario failed to throw NotSupportedException.");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                throw new Exception("One or more scenarios did not complete as expected.");
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/General/NotSupported/Vector128ToVector256Unsafe.cs b/tests/src/JIT/HardwareIntrinsics/General/NotSupported/Vector128ToVector256Unsafe.cs
index 6d45a93e0124..834a63658c52 100644
--- a/tests/src/JIT/HardwareIntrinsics/General/NotSupported/Vector128ToVector256Unsafe.cs
+++ b/tests/src/JIT/HardwareIntrinsics/General/NotSupported/Vector128ToVector256Unsafe.cs
@@ -35,6 +35,8 @@ private static void Vector128ToVector256Unsafe()
             {
                 TestLibrary.TestFramework.LogInformation($"Vector128ToVector256Unsafe: RunNotSupportedScenario failed to throw NotSupportedException.");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                throw new Exception("One or more scenarios did not complete as expected.");
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/General/NotSupported/Vector128UInt16AsGeneric_Boolean.cs b/tests/src/JIT/HardwareIntrinsics/General/NotSupported/Vector128UInt16AsGeneric_Boolean.cs
index 3ecaa8022ed6..1c5035e65bd6 100644
--- a/tests/src/JIT/HardwareIntrinsics/General/NotSupported/Vector128UInt16AsGeneric_Boolean.cs
+++ b/tests/src/JIT/HardwareIntrinsics/General/NotSupported/Vector128UInt16AsGeneric_Boolean.cs
@@ -35,6 +35,8 @@ private static void Vector128UInt16AsGeneric_Boolean()
             {
                 TestLibrary.TestFramework.LogInformation($"Vector128UInt16AsGeneric_Boolean: RunNotSupportedScenario failed to throw NotSupportedException.");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                throw new Exception("One or more scenarios did not complete as expected.");
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/General/NotSupported/Vector128UInt32AsGeneric_Boolean.cs b/tests/src/JIT/HardwareIntrinsics/General/NotSupported/Vector128UInt32AsGeneric_Boolean.cs
index 7c29b9f1f339..194f2aad2d0f 100644
--- a/tests/src/JIT/HardwareIntrinsics/General/NotSupported/Vector128UInt32AsGeneric_Boolean.cs
+++ b/tests/src/JIT/HardwareIntrinsics/General/NotSupported/Vector128UInt32AsGeneric_Boolean.cs
@@ -35,6 +35,8 @@ private static void Vector128UInt32AsGeneric_Boolean()
             {
                 TestLibrary.TestFramework.LogInformation($"Vector128UInt32AsGeneric_Boolean: RunNotSupportedScenario failed to throw NotSupportedException.");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                throw new Exception("One or more scenarios did not complete as expected.");
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/General/NotSupported/Vector128UInt64AsGeneric_Boolean.cs b/tests/src/JIT/HardwareIntrinsics/General/NotSupported/Vector128UInt64AsGeneric_Boolean.cs
index 7e28e14929f0..94a1ce0b89f5 100644
--- a/tests/src/JIT/HardwareIntrinsics/General/NotSupported/Vector128UInt64AsGeneric_Boolean.cs
+++ b/tests/src/JIT/HardwareIntrinsics/General/NotSupported/Vector128UInt64AsGeneric_Boolean.cs
@@ -35,6 +35,8 @@ private static void Vector128UInt64AsGeneric_Boolean()
             {
                 TestLibrary.TestFramework.LogInformation($"Vector128UInt64AsGeneric_Boolean: RunNotSupportedScenario failed to throw NotSupportedException.");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                throw new Exception("One or more scenarios did not complete as expected.");
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/General/NotSupported/Vector128WithElement0.cs b/tests/src/JIT/HardwareIntrinsics/General/NotSupported/Vector128WithElement0.cs
index 612de5321406..7e7f4c960d05 100644
--- a/tests/src/JIT/HardwareIntrinsics/General/NotSupported/Vector128WithElement0.cs
+++ b/tests/src/JIT/HardwareIntrinsics/General/NotSupported/Vector128WithElement0.cs
@@ -35,6 +35,8 @@ private static void Vector128WithElement0()
             {
                 TestLibrary.TestFramework.LogInformation($"Vector128WithElement0: RunNotSupportedScenario failed to throw NotSupportedException.");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                throw new Exception("One or more scenarios did not complete as expected.");
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/General/NotSupported/Vector128WithElementMaxValue.cs b/tests/src/JIT/HardwareIntrinsics/General/NotSupported/Vector128WithElementMaxValue.cs
index 4b05ce5a92bb..285a204ff97f 100644
--- a/tests/src/JIT/HardwareIntrinsics/General/NotSupported/Vector128WithElementMaxValue.cs
+++ b/tests/src/JIT/HardwareIntrinsics/General/NotSupported/Vector128WithElementMaxValue.cs
@@ -35,6 +35,8 @@ private static void Vector128WithElementMaxValue()
             {
                 TestLibrary.TestFramework.LogInformation($"Vector128WithElementMaxValue: RunNotSupportedScenario failed to throw NotSupportedException.");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                throw new Exception("One or more scenarios did not complete as expected.");
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/General/NotSupported/Vector128WithElementNegativeOne.cs b/tests/src/JIT/HardwareIntrinsics/General/NotSupported/Vector128WithElementNegativeOne.cs
index 25286c1b0b51..8ed0aaa344bf 100644
--- a/tests/src/JIT/HardwareIntrinsics/General/NotSupported/Vector128WithElementNegativeOne.cs
+++ b/tests/src/JIT/HardwareIntrinsics/General/NotSupported/Vector128WithElementNegativeOne.cs
@@ -35,6 +35,8 @@ private static void Vector128WithElementNegativeOne()
             {
                 TestLibrary.TestFramework.LogInformation($"Vector128WithElementNegativeOne: RunNotSupportedScenario failed to throw NotSupportedException.");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                throw new Exception("One or more scenarios did not complete as expected.");
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/General/NotSupported/Vector128WithLower.cs b/tests/src/JIT/HardwareIntrinsics/General/NotSupported/Vector128WithLower.cs
index 5355ab702b74..6d3d74b3b1cc 100644
--- a/tests/src/JIT/HardwareIntrinsics/General/NotSupported/Vector128WithLower.cs
+++ b/tests/src/JIT/HardwareIntrinsics/General/NotSupported/Vector128WithLower.cs
@@ -35,6 +35,8 @@ private static void Vector128WithLower()
             {
                 TestLibrary.TestFramework.LogInformation($"Vector128WithLower: RunNotSupportedScenario failed to throw NotSupportedException.");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                throw new Exception("One or more scenarios did not complete as expected.");
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/General/NotSupported/Vector128WithUpper.cs b/tests/src/JIT/HardwareIntrinsics/General/NotSupported/Vector128WithUpper.cs
index c4a9b76c2534..f901e49a887d 100644
--- a/tests/src/JIT/HardwareIntrinsics/General/NotSupported/Vector128WithUpper.cs
+++ b/tests/src/JIT/HardwareIntrinsics/General/NotSupported/Vector128WithUpper.cs
@@ -35,6 +35,8 @@ private static void Vector128WithUpper()
             {
                 TestLibrary.TestFramework.LogInformation($"Vector128WithUpper: RunNotSupportedScenario failed to throw NotSupportedException.");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                throw new Exception("One or more scenarios did not complete as expected.");
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/General/NotSupported/Vector128Zero.cs b/tests/src/JIT/HardwareIntrinsics/General/NotSupported/Vector128Zero.cs
index b5751d48c78b..d2b90eff1532 100644
--- a/tests/src/JIT/HardwareIntrinsics/General/NotSupported/Vector128Zero.cs
+++ b/tests/src/JIT/HardwareIntrinsics/General/NotSupported/Vector128Zero.cs
@@ -35,6 +35,8 @@ private static void Vector128Zero()
             {
                 TestLibrary.TestFramework.LogInformation($"Vector128Zero: RunNotSupportedScenario failed to throw NotSupportedException.");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                throw new Exception("One or more scenarios did not complete as expected.");
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/General/NotSupported/Vector256BooleanAsByte.cs b/tests/src/JIT/HardwareIntrinsics/General/NotSupported/Vector256BooleanAsByte.cs
index fff1b3fe564f..f1209895182e 100644
--- a/tests/src/JIT/HardwareIntrinsics/General/NotSupported/Vector256BooleanAsByte.cs
+++ b/tests/src/JIT/HardwareIntrinsics/General/NotSupported/Vector256BooleanAsByte.cs
@@ -35,6 +35,8 @@ private static void Vector256BooleanAsByte()
             {
                 TestLibrary.TestFramework.LogInformation($"Vector256BooleanAsByte: RunNotSupportedScenario failed to throw NotSupportedException.");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                throw new Exception("One or more scenarios did not complete as expected.");
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/General/NotSupported/Vector256BooleanAsDouble.cs b/tests/src/JIT/HardwareIntrinsics/General/NotSupported/Vector256BooleanAsDouble.cs
index 3c02b03d74fd..a4b32ea4d30d 100644
--- a/tests/src/JIT/HardwareIntrinsics/General/NotSupported/Vector256BooleanAsDouble.cs
+++ b/tests/src/JIT/HardwareIntrinsics/General/NotSupported/Vector256BooleanAsDouble.cs
@@ -35,6 +35,8 @@ private static void Vector256BooleanAsDouble()
             {
                 TestLibrary.TestFramework.LogInformation($"Vector256BooleanAsDouble: RunNotSupportedScenario failed to throw NotSupportedException.");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                throw new Exception("One or more scenarios did not complete as expected.");
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/General/NotSupported/Vector256BooleanAsGeneric_Boolean.cs b/tests/src/JIT/HardwareIntrinsics/General/NotSupported/Vector256BooleanAsGeneric_Boolean.cs
index c029d8897241..e0875d244192 100644
--- a/tests/src/JIT/HardwareIntrinsics/General/NotSupported/Vector256BooleanAsGeneric_Boolean.cs
+++ b/tests/src/JIT/HardwareIntrinsics/General/NotSupported/Vector256BooleanAsGeneric_Boolean.cs
@@ -35,6 +35,8 @@ private static void Vector256BooleanAsGeneric_Boolean()
             {
                 TestLibrary.TestFramework.LogInformation($"Vector256BooleanAsGeneric_Boolean: RunNotSupportedScenario failed to throw NotSupportedException.");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                throw new Exception("One or more scenarios did not complete as expected.");
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/General/NotSupported/Vector256BooleanAsGeneric_Byte.cs b/tests/src/JIT/HardwareIntrinsics/General/NotSupported/Vector256BooleanAsGeneric_Byte.cs
index ea4dd09496bd..a900b67d7006 100644
--- a/tests/src/JIT/HardwareIntrinsics/General/NotSupported/Vector256BooleanAsGeneric_Byte.cs
+++ b/tests/src/JIT/HardwareIntrinsics/General/NotSupported/Vector256BooleanAsGeneric_Byte.cs
@@ -35,6 +35,8 @@ private static void Vector256BooleanAsGeneric_Byte()
             {
                 TestLibrary.TestFramework.LogInformation($"Vector256BooleanAsGeneric_Byte: RunNotSupportedScenario failed to throw NotSupportedException.");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                throw new Exception("One or more scenarios did not complete as expected.");
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/General/NotSupported/Vector256BooleanAsGeneric_Double.cs b/tests/src/JIT/HardwareIntrinsics/General/NotSupported/Vector256BooleanAsGeneric_Double.cs
index 31d6347678fb..e12b75898f90 100644
--- a/tests/src/JIT/HardwareIntrinsics/General/NotSupported/Vector256BooleanAsGeneric_Double.cs
+++ b/tests/src/JIT/HardwareIntrinsics/General/NotSupported/Vector256BooleanAsGeneric_Double.cs
@@ -35,6 +35,8 @@ private static void Vector256BooleanAsGeneric_Double()
             {
                 TestLibrary.TestFramework.LogInformation($"Vector256BooleanAsGeneric_Double: RunNotSupportedScenario failed to throw NotSupportedException.");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                throw new Exception("One or more scenarios did not complete as expected.");
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/General/NotSupported/Vector256BooleanAsGeneric_Int16.cs b/tests/src/JIT/HardwareIntrinsics/General/NotSupported/Vector256BooleanAsGeneric_Int16.cs
index b766758ca8cd..f2549abfd11f 100644
--- a/tests/src/JIT/HardwareIntrinsics/General/NotSupported/Vector256BooleanAsGeneric_Int16.cs
+++ b/tests/src/JIT/HardwareIntrinsics/General/NotSupported/Vector256BooleanAsGeneric_Int16.cs
@@ -35,6 +35,8 @@ private static void Vector256BooleanAsGeneric_Int16()
             {
                 TestLibrary.TestFramework.LogInformation($"Vector256BooleanAsGeneric_Int16: RunNotSupportedScenario failed to throw NotSupportedException.");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                throw new Exception("One or more scenarios did not complete as expected.");
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/General/NotSupported/Vector256BooleanAsGeneric_Int32.cs b/tests/src/JIT/HardwareIntrinsics/General/NotSupported/Vector256BooleanAsGeneric_Int32.cs
index 433d68468d46..42f508eba8f6 100644
--- a/tests/src/JIT/HardwareIntrinsics/General/NotSupported/Vector256BooleanAsGeneric_Int32.cs
+++ b/tests/src/JIT/HardwareIntrinsics/General/NotSupported/Vector256BooleanAsGeneric_Int32.cs
@@ -35,6 +35,8 @@ private static void Vector256BooleanAsGeneric_Int32()
             {
                 TestLibrary.TestFramework.LogInformation($"Vector256BooleanAsGeneric_Int32: RunNotSupportedScenario failed to throw NotSupportedException.");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                throw new Exception("One or more scenarios did not complete as expected.");
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/General/NotSupported/Vector256BooleanAsGeneric_Int64.cs b/tests/src/JIT/HardwareIntrinsics/General/NotSupported/Vector256BooleanAsGeneric_Int64.cs
index 5f1f4d32e977..d9097f28a0e1 100644
--- a/tests/src/JIT/HardwareIntrinsics/General/NotSupported/Vector256BooleanAsGeneric_Int64.cs
+++ b/tests/src/JIT/HardwareIntrinsics/General/NotSupported/Vector256BooleanAsGeneric_Int64.cs
@@ -35,6 +35,8 @@ private static void Vector256BooleanAsGeneric_Int64()
             {
                 TestLibrary.TestFramework.LogInformation($"Vector256BooleanAsGeneric_Int64: RunNotSupportedScenario failed to throw NotSupportedException.");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                throw new Exception("One or more scenarios did not complete as expected.");
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/General/NotSupported/Vector256BooleanAsGeneric_SByte.cs b/tests/src/JIT/HardwareIntrinsics/General/NotSupported/Vector256BooleanAsGeneric_SByte.cs
index 66fa2837fd58..c47f57f283e3 100644
--- a/tests/src/JIT/HardwareIntrinsics/General/NotSupported/Vector256BooleanAsGeneric_SByte.cs
+++ b/tests/src/JIT/HardwareIntrinsics/General/NotSupported/Vector256BooleanAsGeneric_SByte.cs
@@ -35,6 +35,8 @@ private static void Vector256BooleanAsGeneric_SByte()
             {
                 TestLibrary.TestFramework.LogInformation($"Vector256BooleanAsGeneric_SByte: RunNotSupportedScenario failed to throw NotSupportedException.");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                throw new Exception("One or more scenarios did not complete as expected.");
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/General/NotSupported/Vector256BooleanAsGeneric_Single.cs b/tests/src/JIT/HardwareIntrinsics/General/NotSupported/Vector256BooleanAsGeneric_Single.cs
index 8712739de989..fc36aa74bc7d 100644
--- a/tests/src/JIT/HardwareIntrinsics/General/NotSupported/Vector256BooleanAsGeneric_Single.cs
+++ b/tests/src/JIT/HardwareIntrinsics/General/NotSupported/Vector256BooleanAsGeneric_Single.cs
@@ -35,6 +35,8 @@ private static void Vector256BooleanAsGeneric_Single()
             {
                 TestLibrary.TestFramework.LogInformation($"Vector256BooleanAsGeneric_Single: RunNotSupportedScenario failed to throw NotSupportedException.");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                throw new Exception("One or more scenarios did not complete as expected.");
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/General/NotSupported/Vector256BooleanAsGeneric_UInt16.cs b/tests/src/JIT/HardwareIntrinsics/General/NotSupported/Vector256BooleanAsGeneric_UInt16.cs
index 915786150b2c..8e815ba58b6b 100644
--- a/tests/src/JIT/HardwareIntrinsics/General/NotSupported/Vector256BooleanAsGeneric_UInt16.cs
+++ b/tests/src/JIT/HardwareIntrinsics/General/NotSupported/Vector256BooleanAsGeneric_UInt16.cs
@@ -35,6 +35,8 @@ private static void Vector256BooleanAsGeneric_UInt16()
             {
                 TestLibrary.TestFramework.LogInformation($"Vector256BooleanAsGeneric_UInt16: RunNotSupportedScenario failed to throw NotSupportedException.");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                throw new Exception("One or more scenarios did not complete as expected.");
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/General/NotSupported/Vector256BooleanAsGeneric_UInt32.cs b/tests/src/JIT/HardwareIntrinsics/General/NotSupported/Vector256BooleanAsGeneric_UInt32.cs
index b2e027d8c810..b10fd1a6429c 100644
--- a/tests/src/JIT/HardwareIntrinsics/General/NotSupported/Vector256BooleanAsGeneric_UInt32.cs
+++ b/tests/src/JIT/HardwareIntrinsics/General/NotSupported/Vector256BooleanAsGeneric_UInt32.cs
@@ -35,6 +35,8 @@ private static void Vector256BooleanAsGeneric_UInt32()
             {
                 TestLibrary.TestFramework.LogInformation($"Vector256BooleanAsGeneric_UInt32: RunNotSupportedScenario failed to throw NotSupportedException.");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                throw new Exception("One or more scenarios did not complete as expected.");
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/General/NotSupported/Vector256BooleanAsGeneric_UInt64.cs b/tests/src/JIT/HardwareIntrinsics/General/NotSupported/Vector256BooleanAsGeneric_UInt64.cs
index 1f0c5f526e08..410669ee5f48 100644
--- a/tests/src/JIT/HardwareIntrinsics/General/NotSupported/Vector256BooleanAsGeneric_UInt64.cs
+++ b/tests/src/JIT/HardwareIntrinsics/General/NotSupported/Vector256BooleanAsGeneric_UInt64.cs
@@ -35,6 +35,8 @@ private static void Vector256BooleanAsGeneric_UInt64()
             {
                 TestLibrary.TestFramework.LogInformation($"Vector256BooleanAsGeneric_UInt64: RunNotSupportedScenario failed to throw NotSupportedException.");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                throw new Exception("One or more scenarios did not complete as expected.");
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/General/NotSupported/Vector256BooleanAsInt16.cs b/tests/src/JIT/HardwareIntrinsics/General/NotSupported/Vector256BooleanAsInt16.cs
index 98a07229f472..a22e252a73fd 100644
--- a/tests/src/JIT/HardwareIntrinsics/General/NotSupported/Vector256BooleanAsInt16.cs
+++ b/tests/src/JIT/HardwareIntrinsics/General/NotSupported/Vector256BooleanAsInt16.cs
@@ -35,6 +35,8 @@ private static void Vector256BooleanAsInt16()
             {
                 TestLibrary.TestFramework.LogInformation($"Vector256BooleanAsInt16: RunNotSupportedScenario failed to throw NotSupportedException.");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                throw new Exception("One or more scenarios did not complete as expected.");
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/General/NotSupported/Vector256BooleanAsInt32.cs b/tests/src/JIT/HardwareIntrinsics/General/NotSupported/Vector256BooleanAsInt32.cs
index 923551da487f..04628fe2c7e7 100644
--- a/tests/src/JIT/HardwareIntrinsics/General/NotSupported/Vector256BooleanAsInt32.cs
+++ b/tests/src/JIT/HardwareIntrinsics/General/NotSupported/Vector256BooleanAsInt32.cs
@@ -35,6 +35,8 @@ private static void Vector256BooleanAsInt32()
             {
                 TestLibrary.TestFramework.LogInformation($"Vector256BooleanAsInt32: RunNotSupportedScenario failed to throw NotSupportedException.");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                throw new Exception("One or more scenarios did not complete as expected.");
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/General/NotSupported/Vector256BooleanAsInt64.cs b/tests/src/JIT/HardwareIntrinsics/General/NotSupported/Vector256BooleanAsInt64.cs
index 97bca819b603..26a0ca7b9947 100644
--- a/tests/src/JIT/HardwareIntrinsics/General/NotSupported/Vector256BooleanAsInt64.cs
+++ b/tests/src/JIT/HardwareIntrinsics/General/NotSupported/Vector256BooleanAsInt64.cs
@@ -35,6 +35,8 @@ private static void Vector256BooleanAsInt64()
             {
                 TestLibrary.TestFramework.LogInformation($"Vector256BooleanAsInt64: RunNotSupportedScenario failed to throw NotSupportedException.");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                throw new Exception("One or more scenarios did not complete as expected.");
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/General/NotSupported/Vector256BooleanAsSByte.cs b/tests/src/JIT/HardwareIntrinsics/General/NotSupported/Vector256BooleanAsSByte.cs
index c5c85a76298e..9e2e03f2f31a 100644
--- a/tests/src/JIT/HardwareIntrinsics/General/NotSupported/Vector256BooleanAsSByte.cs
+++ b/tests/src/JIT/HardwareIntrinsics/General/NotSupported/Vector256BooleanAsSByte.cs
@@ -35,6 +35,8 @@ private static void Vector256BooleanAsSByte()
             {
                 TestLibrary.TestFramework.LogInformation($"Vector256BooleanAsSByte: RunNotSupportedScenario failed to throw NotSupportedException.");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                throw new Exception("One or more scenarios did not complete as expected.");
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/General/NotSupported/Vector256BooleanAsSingle.cs b/tests/src/JIT/HardwareIntrinsics/General/NotSupported/Vector256BooleanAsSingle.cs
index f1f19ebd80fa..cb76fe856924 100644
--- a/tests/src/JIT/HardwareIntrinsics/General/NotSupported/Vector256BooleanAsSingle.cs
+++ b/tests/src/JIT/HardwareIntrinsics/General/NotSupported/Vector256BooleanAsSingle.cs
@@ -35,6 +35,8 @@ private static void Vector256BooleanAsSingle()
             {
                 TestLibrary.TestFramework.LogInformation($"Vector256BooleanAsSingle: RunNotSupportedScenario failed to throw NotSupportedException.");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                throw new Exception("One or more scenarios did not complete as expected.");
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/General/NotSupported/Vector256BooleanAsUInt16.cs b/tests/src/JIT/HardwareIntrinsics/General/NotSupported/Vector256BooleanAsUInt16.cs
index 0b8894bce337..020fb348c226 100644
--- a/tests/src/JIT/HardwareIntrinsics/General/NotSupported/Vector256BooleanAsUInt16.cs
+++ b/tests/src/JIT/HardwareIntrinsics/General/NotSupported/Vector256BooleanAsUInt16.cs
@@ -35,6 +35,8 @@ private static void Vector256BooleanAsUInt16()
             {
                 TestLibrary.TestFramework.LogInformation($"Vector256BooleanAsUInt16: RunNotSupportedScenario failed to throw NotSupportedException.");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                throw new Exception("One or more scenarios did not complete as expected.");
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/General/NotSupported/Vector256BooleanAsUInt32.cs b/tests/src/JIT/HardwareIntrinsics/General/NotSupported/Vector256BooleanAsUInt32.cs
index 3592a87bdc88..40d38e5b20f8 100644
--- a/tests/src/JIT/HardwareIntrinsics/General/NotSupported/Vector256BooleanAsUInt32.cs
+++ b/tests/src/JIT/HardwareIntrinsics/General/NotSupported/Vector256BooleanAsUInt32.cs
@@ -35,6 +35,8 @@ private static void Vector256BooleanAsUInt32()
             {
                 TestLibrary.TestFramework.LogInformation($"Vector256BooleanAsUInt32: RunNotSupportedScenario failed to throw NotSupportedException.");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                throw new Exception("One or more scenarios did not complete as expected.");
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/General/NotSupported/Vector256BooleanAsUInt64.cs b/tests/src/JIT/HardwareIntrinsics/General/NotSupported/Vector256BooleanAsUInt64.cs
index 186ab74a83a4..0321e1206c1c 100644
--- a/tests/src/JIT/HardwareIntrinsics/General/NotSupported/Vector256BooleanAsUInt64.cs
+++ b/tests/src/JIT/HardwareIntrinsics/General/NotSupported/Vector256BooleanAsUInt64.cs
@@ -35,6 +35,8 @@ private static void Vector256BooleanAsUInt64()
             {
                 TestLibrary.TestFramework.LogInformation($"Vector256BooleanAsUInt64: RunNotSupportedScenario failed to throw NotSupportedException.");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                throw new Exception("One or more scenarios did not complete as expected.");
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/General/NotSupported/Vector256ByteAsGeneric_Boolean.cs b/tests/src/JIT/HardwareIntrinsics/General/NotSupported/Vector256ByteAsGeneric_Boolean.cs
index 867f954fa114..694804f2ad61 100644
--- a/tests/src/JIT/HardwareIntrinsics/General/NotSupported/Vector256ByteAsGeneric_Boolean.cs
+++ b/tests/src/JIT/HardwareIntrinsics/General/NotSupported/Vector256ByteAsGeneric_Boolean.cs
@@ -35,6 +35,8 @@ private static void Vector256ByteAsGeneric_Boolean()
             {
                 TestLibrary.TestFramework.LogInformation($"Vector256ByteAsGeneric_Boolean: RunNotSupportedScenario failed to throw NotSupportedException.");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                throw new Exception("One or more scenarios did not complete as expected.");
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/General/NotSupported/Vector256DoubleAsGeneric_Boolean.cs b/tests/src/JIT/HardwareIntrinsics/General/NotSupported/Vector256DoubleAsGeneric_Boolean.cs
index 7d2b8ffc9594..be6a48e5da84 100644
--- a/tests/src/JIT/HardwareIntrinsics/General/NotSupported/Vector256DoubleAsGeneric_Boolean.cs
+++ b/tests/src/JIT/HardwareIntrinsics/General/NotSupported/Vector256DoubleAsGeneric_Boolean.cs
@@ -35,6 +35,8 @@ private static void Vector256DoubleAsGeneric_Boolean()
             {
                 TestLibrary.TestFramework.LogInformation($"Vector256DoubleAsGeneric_Boolean: RunNotSupportedScenario failed to throw NotSupportedException.");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                throw new Exception("One or more scenarios did not complete as expected.");
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/General/NotSupported/Vector256GetElement0.cs b/tests/src/JIT/HardwareIntrinsics/General/NotSupported/Vector256GetElement0.cs
index 627663a1227e..572d9e596c94 100644
--- a/tests/src/JIT/HardwareIntrinsics/General/NotSupported/Vector256GetElement0.cs
+++ b/tests/src/JIT/HardwareIntrinsics/General/NotSupported/Vector256GetElement0.cs
@@ -35,6 +35,8 @@ private static void Vector256GetElement0()
             {
                 TestLibrary.TestFramework.LogInformation($"Vector256GetElement0: RunNotSupportedScenario failed to throw NotSupportedException.");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                throw new Exception("One or more scenarios did not complete as expected.");
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/General/NotSupported/Vector256GetElementMaxValue.cs b/tests/src/JIT/HardwareIntrinsics/General/NotSupported/Vector256GetElementMaxValue.cs
index 27751ac97dd9..af6a4dd256de 100644
--- a/tests/src/JIT/HardwareIntrinsics/General/NotSupported/Vector256GetElementMaxValue.cs
+++ b/tests/src/JIT/HardwareIntrinsics/General/NotSupported/Vector256GetElementMaxValue.cs
@@ -35,6 +35,8 @@ private static void Vector256GetElementMaxValue()
             {
                 TestLibrary.TestFramework.LogInformation($"Vector256GetElementMaxValue: RunNotSupportedScenario failed to throw NotSupportedException.");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                throw new Exception("One or more scenarios did not complete as expected.");
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/General/NotSupported/Vector256GetElementNegativeOne.cs b/tests/src/JIT/HardwareIntrinsics/General/NotSupported/Vector256GetElementNegativeOne.cs
index 4157ffeb89d5..373a04ccc7f3 100644
--- a/tests/src/JIT/HardwareIntrinsics/General/NotSupported/Vector256GetElementNegativeOne.cs
+++ b/tests/src/JIT/HardwareIntrinsics/General/NotSupported/Vector256GetElementNegativeOne.cs
@@ -35,6 +35,8 @@ private static void Vector256GetElementNegativeOne()
             {
                 TestLibrary.TestFramework.LogInformation($"Vector256GetElementNegativeOne: RunNotSupportedScenario failed to throw NotSupportedException.");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                throw new Exception("One or more scenarios did not complete as expected.");
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/General/NotSupported/Vector256GetLower.cs b/tests/src/JIT/HardwareIntrinsics/General/NotSupported/Vector256GetLower.cs
index 4b721745a6c8..6146fd2f2916 100644
--- a/tests/src/JIT/HardwareIntrinsics/General/NotSupported/Vector256GetLower.cs
+++ b/tests/src/JIT/HardwareIntrinsics/General/NotSupported/Vector256GetLower.cs
@@ -35,6 +35,8 @@ private static void Vector256GetLower()
             {
                 TestLibrary.TestFramework.LogInformation($"Vector256GetLower: RunNotSupportedScenario failed to throw NotSupportedException.");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                throw new Exception("One or more scenarios did not complete as expected.");
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/General/NotSupported/Vector256GetUpper.cs b/tests/src/JIT/HardwareIntrinsics/General/NotSupported/Vector256GetUpper.cs
index b56d07341719..8e528c690c2f 100644
--- a/tests/src/JIT/HardwareIntrinsics/General/NotSupported/Vector256GetUpper.cs
+++ b/tests/src/JIT/HardwareIntrinsics/General/NotSupported/Vector256GetUpper.cs
@@ -35,6 +35,8 @@ private static void Vector256GetUpper()
             {
                 TestLibrary.TestFramework.LogInformation($"Vector256GetUpper: RunNotSupportedScenario failed to throw NotSupportedException.");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                throw new Exception("One or more scenarios did not complete as expected.");
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/General/NotSupported/Vector256Int16AsGeneric_Boolean.cs b/tests/src/JIT/HardwareIntrinsics/General/NotSupported/Vector256Int16AsGeneric_Boolean.cs
index 060b18e0a619..d907cc2a40b4 100644
--- a/tests/src/JIT/HardwareIntrinsics/General/NotSupported/Vector256Int16AsGeneric_Boolean.cs
+++ b/tests/src/JIT/HardwareIntrinsics/General/NotSupported/Vector256Int16AsGeneric_Boolean.cs
@@ -35,6 +35,8 @@ private static void Vector256Int16AsGeneric_Boolean()
             {
                 TestLibrary.TestFramework.LogInformation($"Vector256Int16AsGeneric_Boolean: RunNotSupportedScenario failed to throw NotSupportedException.");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                throw new Exception("One or more scenarios did not complete as expected.");
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/General/NotSupported/Vector256Int32AsGeneric_Boolean.cs b/tests/src/JIT/HardwareIntrinsics/General/NotSupported/Vector256Int32AsGeneric_Boolean.cs
index e2963fca0d5f..5a2c4ef9e6d0 100644
--- a/tests/src/JIT/HardwareIntrinsics/General/NotSupported/Vector256Int32AsGeneric_Boolean.cs
+++ b/tests/src/JIT/HardwareIntrinsics/General/NotSupported/Vector256Int32AsGeneric_Boolean.cs
@@ -35,6 +35,8 @@ private static void Vector256Int32AsGeneric_Boolean()
             {
                 TestLibrary.TestFramework.LogInformation($"Vector256Int32AsGeneric_Boolean: RunNotSupportedScenario failed to throw NotSupportedException.");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                throw new Exception("One or more scenarios did not complete as expected.");
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/General/NotSupported/Vector256Int64AsGeneric_Boolean.cs b/tests/src/JIT/HardwareIntrinsics/General/NotSupported/Vector256Int64AsGeneric_Boolean.cs
index 1b59ca11dea1..f41916bb37f1 100644
--- a/tests/src/JIT/HardwareIntrinsics/General/NotSupported/Vector256Int64AsGeneric_Boolean.cs
+++ b/tests/src/JIT/HardwareIntrinsics/General/NotSupported/Vector256Int64AsGeneric_Boolean.cs
@@ -35,6 +35,8 @@ private static void Vector256Int64AsGeneric_Boolean()
             {
                 TestLibrary.TestFramework.LogInformation($"Vector256Int64AsGeneric_Boolean: RunNotSupportedScenario failed to throw NotSupportedException.");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                throw new Exception("One or more scenarios did not complete as expected.");
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/General/NotSupported/Vector256SByteAsGeneric_Boolean.cs b/tests/src/JIT/HardwareIntrinsics/General/NotSupported/Vector256SByteAsGeneric_Boolean.cs
index 13517c14d124..f5ea487d00f8 100644
--- a/tests/src/JIT/HardwareIntrinsics/General/NotSupported/Vector256SByteAsGeneric_Boolean.cs
+++ b/tests/src/JIT/HardwareIntrinsics/General/NotSupported/Vector256SByteAsGeneric_Boolean.cs
@@ -35,6 +35,8 @@ private static void Vector256SByteAsGeneric_Boolean()
             {
                 TestLibrary.TestFramework.LogInformation($"Vector256SByteAsGeneric_Boolean: RunNotSupportedScenario failed to throw NotSupportedException.");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                throw new Exception("One or more scenarios did not complete as expected.");
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/General/NotSupported/Vector256SingleAsGeneric_Boolean.cs b/tests/src/JIT/HardwareIntrinsics/General/NotSupported/Vector256SingleAsGeneric_Boolean.cs
index 7afd2094a23a..07a575db2641 100644
--- a/tests/src/JIT/HardwareIntrinsics/General/NotSupported/Vector256SingleAsGeneric_Boolean.cs
+++ b/tests/src/JIT/HardwareIntrinsics/General/NotSupported/Vector256SingleAsGeneric_Boolean.cs
@@ -35,6 +35,8 @@ private static void Vector256SingleAsGeneric_Boolean()
             {
                 TestLibrary.TestFramework.LogInformation($"Vector256SingleAsGeneric_Boolean: RunNotSupportedScenario failed to throw NotSupportedException.");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                throw new Exception("One or more scenarios did not complete as expected.");
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/General/NotSupported/Vector256ToScalar.cs b/tests/src/JIT/HardwareIntrinsics/General/NotSupported/Vector256ToScalar.cs
index 70f00128c41d..f4b150d684fa 100644
--- a/tests/src/JIT/HardwareIntrinsics/General/NotSupported/Vector256ToScalar.cs
+++ b/tests/src/JIT/HardwareIntrinsics/General/NotSupported/Vector256ToScalar.cs
@@ -35,6 +35,8 @@ private static void Vector256ToScalar()
             {
                 TestLibrary.TestFramework.LogInformation($"Vector256ToScalar: RunNotSupportedScenario failed to throw NotSupportedException.");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                throw new Exception("One or more scenarios did not complete as expected.");
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/General/NotSupported/Vector256UInt16AsGeneric_Boolean.cs b/tests/src/JIT/HardwareIntrinsics/General/NotSupported/Vector256UInt16AsGeneric_Boolean.cs
index 1b5a4a019666..3122c44a9086 100644
--- a/tests/src/JIT/HardwareIntrinsics/General/NotSupported/Vector256UInt16AsGeneric_Boolean.cs
+++ b/tests/src/JIT/HardwareIntrinsics/General/NotSupported/Vector256UInt16AsGeneric_Boolean.cs
@@ -35,6 +35,8 @@ private static void Vector256UInt16AsGeneric_Boolean()
             {
                 TestLibrary.TestFramework.LogInformation($"Vector256UInt16AsGeneric_Boolean: RunNotSupportedScenario failed to throw NotSupportedException.");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                throw new Exception("One or more scenarios did not complete as expected.");
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/General/NotSupported/Vector256UInt32AsGeneric_Boolean.cs b/tests/src/JIT/HardwareIntrinsics/General/NotSupported/Vector256UInt32AsGeneric_Boolean.cs
index db4fb1cd0bf3..2dbde965e6b2 100644
--- a/tests/src/JIT/HardwareIntrinsics/General/NotSupported/Vector256UInt32AsGeneric_Boolean.cs
+++ b/tests/src/JIT/HardwareIntrinsics/General/NotSupported/Vector256UInt32AsGeneric_Boolean.cs
@@ -35,6 +35,8 @@ private static void Vector256UInt32AsGeneric_Boolean()
             {
                 TestLibrary.TestFramework.LogInformation($"Vector256UInt32AsGeneric_Boolean: RunNotSupportedScenario failed to throw NotSupportedException.");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                throw new Exception("One or more scenarios did not complete as expected.");
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/General/NotSupported/Vector256UInt64AsGeneric_Boolean.cs b/tests/src/JIT/HardwareIntrinsics/General/NotSupported/Vector256UInt64AsGeneric_Boolean.cs
index 3b71753901e4..026e72696d9e 100644
--- a/tests/src/JIT/HardwareIntrinsics/General/NotSupported/Vector256UInt64AsGeneric_Boolean.cs
+++ b/tests/src/JIT/HardwareIntrinsics/General/NotSupported/Vector256UInt64AsGeneric_Boolean.cs
@@ -35,6 +35,8 @@ private static void Vector256UInt64AsGeneric_Boolean()
             {
                 TestLibrary.TestFramework.LogInformation($"Vector256UInt64AsGeneric_Boolean: RunNotSupportedScenario failed to throw NotSupportedException.");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                throw new Exception("One or more scenarios did not complete as expected.");
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/General/NotSupported/Vector256WithElement0.cs b/tests/src/JIT/HardwareIntrinsics/General/NotSupported/Vector256WithElement0.cs
index 2721589bc287..6002ae8ff2d4 100644
--- a/tests/src/JIT/HardwareIntrinsics/General/NotSupported/Vector256WithElement0.cs
+++ b/tests/src/JIT/HardwareIntrinsics/General/NotSupported/Vector256WithElement0.cs
@@ -35,6 +35,8 @@ private static void Vector256WithElement0()
             {
                 TestLibrary.TestFramework.LogInformation($"Vector256WithElement0: RunNotSupportedScenario failed to throw NotSupportedException.");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                throw new Exception("One or more scenarios did not complete as expected.");
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/General/NotSupported/Vector256WithElementMaxValue.cs b/tests/src/JIT/HardwareIntrinsics/General/NotSupported/Vector256WithElementMaxValue.cs
index f89ff54b17f3..bbc8bcea2b04 100644
--- a/tests/src/JIT/HardwareIntrinsics/General/NotSupported/Vector256WithElementMaxValue.cs
+++ b/tests/src/JIT/HardwareIntrinsics/General/NotSupported/Vector256WithElementMaxValue.cs
@@ -35,6 +35,8 @@ private static void Vector256WithElementMaxValue()
             {
                 TestLibrary.TestFramework.LogInformation($"Vector256WithElementMaxValue: RunNotSupportedScenario failed to throw NotSupportedException.");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                throw new Exception("One or more scenarios did not complete as expected.");
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/General/NotSupported/Vector256WithElementNegativeOne.cs b/tests/src/JIT/HardwareIntrinsics/General/NotSupported/Vector256WithElementNegativeOne.cs
index 54370c996335..fa9279545f71 100644
--- a/tests/src/JIT/HardwareIntrinsics/General/NotSupported/Vector256WithElementNegativeOne.cs
+++ b/tests/src/JIT/HardwareIntrinsics/General/NotSupported/Vector256WithElementNegativeOne.cs
@@ -35,6 +35,8 @@ private static void Vector256WithElementNegativeOne()
             {
                 TestLibrary.TestFramework.LogInformation($"Vector256WithElementNegativeOne: RunNotSupportedScenario failed to throw NotSupportedException.");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                throw new Exception("One or more scenarios did not complete as expected.");
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/General/NotSupported/Vector256WithLower.cs b/tests/src/JIT/HardwareIntrinsics/General/NotSupported/Vector256WithLower.cs
index 88592a678b22..0439bd3551a2 100644
--- a/tests/src/JIT/HardwareIntrinsics/General/NotSupported/Vector256WithLower.cs
+++ b/tests/src/JIT/HardwareIntrinsics/General/NotSupported/Vector256WithLower.cs
@@ -35,6 +35,8 @@ private static void Vector256WithLower()
             {
                 TestLibrary.TestFramework.LogInformation($"Vector256WithLower: RunNotSupportedScenario failed to throw NotSupportedException.");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                throw new Exception("One or more scenarios did not complete as expected.");
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/General/NotSupported/Vector256WithUpper.cs b/tests/src/JIT/HardwareIntrinsics/General/NotSupported/Vector256WithUpper.cs
index 78b1a9be11bb..e7ccbe680bf6 100644
--- a/tests/src/JIT/HardwareIntrinsics/General/NotSupported/Vector256WithUpper.cs
+++ b/tests/src/JIT/HardwareIntrinsics/General/NotSupported/Vector256WithUpper.cs
@@ -35,6 +35,8 @@ private static void Vector256WithUpper()
             {
                 TestLibrary.TestFramework.LogInformation($"Vector256WithUpper: RunNotSupportedScenario failed to throw NotSupportedException.");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                throw new Exception("One or more scenarios did not complete as expected.");
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/General/NotSupported/Vector256Zero.cs b/tests/src/JIT/HardwareIntrinsics/General/NotSupported/Vector256Zero.cs
index bc94e4c47220..7b4d0f621eda 100644
--- a/tests/src/JIT/HardwareIntrinsics/General/NotSupported/Vector256Zero.cs
+++ b/tests/src/JIT/HardwareIntrinsics/General/NotSupported/Vector256Zero.cs
@@ -35,6 +35,8 @@ private static void Vector256Zero()
             {
                 TestLibrary.TestFramework.LogInformation($"Vector256Zero: RunNotSupportedScenario failed to throw NotSupportedException.");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                throw new Exception("One or more scenarios did not complete as expected.");
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/General/NotSupported/Vector64BooleanAsByte.cs b/tests/src/JIT/HardwareIntrinsics/General/NotSupported/Vector64BooleanAsByte.cs
index 86ed93617349..658023018d79 100644
--- a/tests/src/JIT/HardwareIntrinsics/General/NotSupported/Vector64BooleanAsByte.cs
+++ b/tests/src/JIT/HardwareIntrinsics/General/NotSupported/Vector64BooleanAsByte.cs
@@ -35,6 +35,8 @@ private static void Vector64BooleanAsByte()
             {
                 TestLibrary.TestFramework.LogInformation($"Vector64BooleanAsByte: RunNotSupportedScenario failed to throw NotSupportedException.");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                throw new Exception("One or more scenarios did not complete as expected.");
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/General/NotSupported/Vector64BooleanAsDouble.cs b/tests/src/JIT/HardwareIntrinsics/General/NotSupported/Vector64BooleanAsDouble.cs
index f6ccf9047c18..748bbed01c52 100644
--- a/tests/src/JIT/HardwareIntrinsics/General/NotSupported/Vector64BooleanAsDouble.cs
+++ b/tests/src/JIT/HardwareIntrinsics/General/NotSupported/Vector64BooleanAsDouble.cs
@@ -35,6 +35,8 @@ private static void Vector64BooleanAsDouble()
             {
                 TestLibrary.TestFramework.LogInformation($"Vector64BooleanAsDouble: RunNotSupportedScenario failed to throw NotSupportedException.");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                throw new Exception("One or more scenarios did not complete as expected.");
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/General/NotSupported/Vector64BooleanAsGeneric_Boolean.cs b/tests/src/JIT/HardwareIntrinsics/General/NotSupported/Vector64BooleanAsGeneric_Boolean.cs
index 121274c5852e..506bb6cf1ca2 100644
--- a/tests/src/JIT/HardwareIntrinsics/General/NotSupported/Vector64BooleanAsGeneric_Boolean.cs
+++ b/tests/src/JIT/HardwareIntrinsics/General/NotSupported/Vector64BooleanAsGeneric_Boolean.cs
@@ -35,6 +35,8 @@ private static void Vector64BooleanAsGeneric_Boolean()
             {
                 TestLibrary.TestFramework.LogInformation($"Vector64BooleanAsGeneric_Boolean: RunNotSupportedScenario failed to throw NotSupportedException.");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                throw new Exception("One or more scenarios did not complete as expected.");
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/General/NotSupported/Vector64BooleanAsGeneric_Byte.cs b/tests/src/JIT/HardwareIntrinsics/General/NotSupported/Vector64BooleanAsGeneric_Byte.cs
index 1c53f6a298bc..3e1e0829dbe0 100644
--- a/tests/src/JIT/HardwareIntrinsics/General/NotSupported/Vector64BooleanAsGeneric_Byte.cs
+++ b/tests/src/JIT/HardwareIntrinsics/General/NotSupported/Vector64BooleanAsGeneric_Byte.cs
@@ -35,6 +35,8 @@ private static void Vector64BooleanAsGeneric_Byte()
             {
                 TestLibrary.TestFramework.LogInformation($"Vector64BooleanAsGeneric_Byte: RunNotSupportedScenario failed to throw NotSupportedException.");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                throw new Exception("One or more scenarios did not complete as expected.");
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/General/NotSupported/Vector64BooleanAsGeneric_Double.cs b/tests/src/JIT/HardwareIntrinsics/General/NotSupported/Vector64BooleanAsGeneric_Double.cs
index bde45cea8152..cd867a621a16 100644
--- a/tests/src/JIT/HardwareIntrinsics/General/NotSupported/Vector64BooleanAsGeneric_Double.cs
+++ b/tests/src/JIT/HardwareIntrinsics/General/NotSupported/Vector64BooleanAsGeneric_Double.cs
@@ -35,6 +35,8 @@ private static void Vector64BooleanAsGeneric_Double()
             {
                 TestLibrary.TestFramework.LogInformation($"Vector64BooleanAsGeneric_Double: RunNotSupportedScenario failed to throw NotSupportedException.");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                throw new Exception("One or more scenarios did not complete as expected.");
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/General/NotSupported/Vector64BooleanAsGeneric_Int16.cs b/tests/src/JIT/HardwareIntrinsics/General/NotSupported/Vector64BooleanAsGeneric_Int16.cs
index 88018c847a52..41721fe7ce3b 100644
--- a/tests/src/JIT/HardwareIntrinsics/General/NotSupported/Vector64BooleanAsGeneric_Int16.cs
+++ b/tests/src/JIT/HardwareIntrinsics/General/NotSupported/Vector64BooleanAsGeneric_Int16.cs
@@ -35,6 +35,8 @@ private static void Vector64BooleanAsGeneric_Int16()
             {
                 TestLibrary.TestFramework.LogInformation($"Vector64BooleanAsGeneric_Int16: RunNotSupportedScenario failed to throw NotSupportedException.");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                throw new Exception("One or more scenarios did not complete as expected.");
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/General/NotSupported/Vector64BooleanAsGeneric_Int32.cs b/tests/src/JIT/HardwareIntrinsics/General/NotSupported/Vector64BooleanAsGeneric_Int32.cs
index 09b6f2653fde..e76bfc103aae 100644
--- a/tests/src/JIT/HardwareIntrinsics/General/NotSupported/Vector64BooleanAsGeneric_Int32.cs
+++ b/tests/src/JIT/HardwareIntrinsics/General/NotSupported/Vector64BooleanAsGeneric_Int32.cs
@@ -35,6 +35,8 @@ private static void Vector64BooleanAsGeneric_Int32()
             {
                 TestLibrary.TestFramework.LogInformation($"Vector64BooleanAsGeneric_Int32: RunNotSupportedScenario failed to throw NotSupportedException.");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                throw new Exception("One or more scenarios did not complete as expected.");
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/General/NotSupported/Vector64BooleanAsGeneric_Int64.cs b/tests/src/JIT/HardwareIntrinsics/General/NotSupported/Vector64BooleanAsGeneric_Int64.cs
index 6b7e902f38ec..9695bafaa4bd 100644
--- a/tests/src/JIT/HardwareIntrinsics/General/NotSupported/Vector64BooleanAsGeneric_Int64.cs
+++ b/tests/src/JIT/HardwareIntrinsics/General/NotSupported/Vector64BooleanAsGeneric_Int64.cs
@@ -35,6 +35,8 @@ private static void Vector64BooleanAsGeneric_Int64()
             {
                 TestLibrary.TestFramework.LogInformation($"Vector64BooleanAsGeneric_Int64: RunNotSupportedScenario failed to throw NotSupportedException.");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                throw new Exception("One or more scenarios did not complete as expected.");
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/General/NotSupported/Vector64BooleanAsGeneric_SByte.cs b/tests/src/JIT/HardwareIntrinsics/General/NotSupported/Vector64BooleanAsGeneric_SByte.cs
index 26a428eb5fcc..77ee4acbd8c7 100644
--- a/tests/src/JIT/HardwareIntrinsics/General/NotSupported/Vector64BooleanAsGeneric_SByte.cs
+++ b/tests/src/JIT/HardwareIntrinsics/General/NotSupported/Vector64BooleanAsGeneric_SByte.cs
@@ -35,6 +35,8 @@ private static void Vector64BooleanAsGeneric_SByte()
             {
                 TestLibrary.TestFramework.LogInformation($"Vector64BooleanAsGeneric_SByte: RunNotSupportedScenario failed to throw NotSupportedException.");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                throw new Exception("One or more scenarios did not complete as expected.");
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/General/NotSupported/Vector64BooleanAsGeneric_Single.cs b/tests/src/JIT/HardwareIntrinsics/General/NotSupported/Vector64BooleanAsGeneric_Single.cs
index 3b3a95074a4f..16fe664e632b 100644
--- a/tests/src/JIT/HardwareIntrinsics/General/NotSupported/Vector64BooleanAsGeneric_Single.cs
+++ b/tests/src/JIT/HardwareIntrinsics/General/NotSupported/Vector64BooleanAsGeneric_Single.cs
@@ -35,6 +35,8 @@ private static void Vector64BooleanAsGeneric_Single()
             {
                 TestLibrary.TestFramework.LogInformation($"Vector64BooleanAsGeneric_Single: RunNotSupportedScenario failed to throw NotSupportedException.");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                throw new Exception("One or more scenarios did not complete as expected.");
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/General/NotSupported/Vector64BooleanAsGeneric_UInt16.cs b/tests/src/JIT/HardwareIntrinsics/General/NotSupported/Vector64BooleanAsGeneric_UInt16.cs
index ea3cc488407e..fdd07564522c 100644
--- a/tests/src/JIT/HardwareIntrinsics/General/NotSupported/Vector64BooleanAsGeneric_UInt16.cs
+++ b/tests/src/JIT/HardwareIntrinsics/General/NotSupported/Vector64BooleanAsGeneric_UInt16.cs
@@ -35,6 +35,8 @@ private static void Vector64BooleanAsGeneric_UInt16()
             {
                 TestLibrary.TestFramework.LogInformation($"Vector64BooleanAsGeneric_UInt16: RunNotSupportedScenario failed to throw NotSupportedException.");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                throw new Exception("One or more scenarios did not complete as expected.");
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/General/NotSupported/Vector64BooleanAsGeneric_UInt32.cs b/tests/src/JIT/HardwareIntrinsics/General/NotSupported/Vector64BooleanAsGeneric_UInt32.cs
index 846ae4815f1e..ef3ab65ccac8 100644
--- a/tests/src/JIT/HardwareIntrinsics/General/NotSupported/Vector64BooleanAsGeneric_UInt32.cs
+++ b/tests/src/JIT/HardwareIntrinsics/General/NotSupported/Vector64BooleanAsGeneric_UInt32.cs
@@ -35,6 +35,8 @@ private static void Vector64BooleanAsGeneric_UInt32()
             {
                 TestLibrary.TestFramework.LogInformation($"Vector64BooleanAsGeneric_UInt32: RunNotSupportedScenario failed to throw NotSupportedException.");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                throw new Exception("One or more scenarios did not complete as expected.");
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/General/NotSupported/Vector64BooleanAsGeneric_UInt64.cs b/tests/src/JIT/HardwareIntrinsics/General/NotSupported/Vector64BooleanAsGeneric_UInt64.cs
index b61815cd71d4..1511821f5cb5 100644
--- a/tests/src/JIT/HardwareIntrinsics/General/NotSupported/Vector64BooleanAsGeneric_UInt64.cs
+++ b/tests/src/JIT/HardwareIntrinsics/General/NotSupported/Vector64BooleanAsGeneric_UInt64.cs
@@ -35,6 +35,8 @@ private static void Vector64BooleanAsGeneric_UInt64()
             {
                 TestLibrary.TestFramework.LogInformation($"Vector64BooleanAsGeneric_UInt64: RunNotSupportedScenario failed to throw NotSupportedException.");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                throw new Exception("One or more scenarios did not complete as expected.");
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/General/NotSupported/Vector64BooleanAsInt16.cs b/tests/src/JIT/HardwareIntrinsics/General/NotSupported/Vector64BooleanAsInt16.cs
index dae2902ee178..2f2ec145cda4 100644
--- a/tests/src/JIT/HardwareIntrinsics/General/NotSupported/Vector64BooleanAsInt16.cs
+++ b/tests/src/JIT/HardwareIntrinsics/General/NotSupported/Vector64BooleanAsInt16.cs
@@ -35,6 +35,8 @@ private static void Vector64BooleanAsInt16()
             {
                 TestLibrary.TestFramework.LogInformation($"Vector64BooleanAsInt16: RunNotSupportedScenario failed to throw NotSupportedException.");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                throw new Exception("One or more scenarios did not complete as expected.");
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/General/NotSupported/Vector64BooleanAsInt32.cs b/tests/src/JIT/HardwareIntrinsics/General/NotSupported/Vector64BooleanAsInt32.cs
index fe3b7f3b560b..a761ff8b8194 100644
--- a/tests/src/JIT/HardwareIntrinsics/General/NotSupported/Vector64BooleanAsInt32.cs
+++ b/tests/src/JIT/HardwareIntrinsics/General/NotSupported/Vector64BooleanAsInt32.cs
@@ -35,6 +35,8 @@ private static void Vector64BooleanAsInt32()
             {
                 TestLibrary.TestFramework.LogInformation($"Vector64BooleanAsInt32: RunNotSupportedScenario failed to throw NotSupportedException.");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                throw new Exception("One or more scenarios did not complete as expected.");
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/General/NotSupported/Vector64BooleanAsInt64.cs b/tests/src/JIT/HardwareIntrinsics/General/NotSupported/Vector64BooleanAsInt64.cs
index e0ba02dac274..e3854ac91a7a 100644
--- a/tests/src/JIT/HardwareIntrinsics/General/NotSupported/Vector64BooleanAsInt64.cs
+++ b/tests/src/JIT/HardwareIntrinsics/General/NotSupported/Vector64BooleanAsInt64.cs
@@ -35,6 +35,8 @@ private static void Vector64BooleanAsInt64()
             {
                 TestLibrary.TestFramework.LogInformation($"Vector64BooleanAsInt64: RunNotSupportedScenario failed to throw NotSupportedException.");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                throw new Exception("One or more scenarios did not complete as expected.");
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/General/NotSupported/Vector64BooleanAsSByte.cs b/tests/src/JIT/HardwareIntrinsics/General/NotSupported/Vector64BooleanAsSByte.cs
index 588919ef2605..aa214435fc22 100644
--- a/tests/src/JIT/HardwareIntrinsics/General/NotSupported/Vector64BooleanAsSByte.cs
+++ b/tests/src/JIT/HardwareIntrinsics/General/NotSupported/Vector64BooleanAsSByte.cs
@@ -35,6 +35,8 @@ private static void Vector64BooleanAsSByte()
             {
                 TestLibrary.TestFramework.LogInformation($"Vector64BooleanAsSByte: RunNotSupportedScenario failed to throw NotSupportedException.");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                throw new Exception("One or more scenarios did not complete as expected.");
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/General/NotSupported/Vector64BooleanAsSingle.cs b/tests/src/JIT/HardwareIntrinsics/General/NotSupported/Vector64BooleanAsSingle.cs
index e0f1cabfed28..1c2caa9ec443 100644
--- a/tests/src/JIT/HardwareIntrinsics/General/NotSupported/Vector64BooleanAsSingle.cs
+++ b/tests/src/JIT/HardwareIntrinsics/General/NotSupported/Vector64BooleanAsSingle.cs
@@ -35,6 +35,8 @@ private static void Vector64BooleanAsSingle()
             {
                 TestLibrary.TestFramework.LogInformation($"Vector64BooleanAsSingle: RunNotSupportedScenario failed to throw NotSupportedException.");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                throw new Exception("One or more scenarios did not complete as expected.");
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/General/NotSupported/Vector64BooleanAsUInt16.cs b/tests/src/JIT/HardwareIntrinsics/General/NotSupported/Vector64BooleanAsUInt16.cs
index a20fb449329a..e71c8b263d47 100644
--- a/tests/src/JIT/HardwareIntrinsics/General/NotSupported/Vector64BooleanAsUInt16.cs
+++ b/tests/src/JIT/HardwareIntrinsics/General/NotSupported/Vector64BooleanAsUInt16.cs
@@ -35,6 +35,8 @@ private static void Vector64BooleanAsUInt16()
             {
                 TestLibrary.TestFramework.LogInformation($"Vector64BooleanAsUInt16: RunNotSupportedScenario failed to throw NotSupportedException.");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                throw new Exception("One or more scenarios did not complete as expected.");
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/General/NotSupported/Vector64BooleanAsUInt32.cs b/tests/src/JIT/HardwareIntrinsics/General/NotSupported/Vector64BooleanAsUInt32.cs
index 8ee2e27997d8..01c0bd9aa7d2 100644
--- a/tests/src/JIT/HardwareIntrinsics/General/NotSupported/Vector64BooleanAsUInt32.cs
+++ b/tests/src/JIT/HardwareIntrinsics/General/NotSupported/Vector64BooleanAsUInt32.cs
@@ -35,6 +35,8 @@ private static void Vector64BooleanAsUInt32()
             {
                 TestLibrary.TestFramework.LogInformation($"Vector64BooleanAsUInt32: RunNotSupportedScenario failed to throw NotSupportedException.");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                throw new Exception("One or more scenarios did not complete as expected.");
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/General/NotSupported/Vector64BooleanAsUInt64.cs b/tests/src/JIT/HardwareIntrinsics/General/NotSupported/Vector64BooleanAsUInt64.cs
index c456dfd725d1..ae8a54bf6980 100644
--- a/tests/src/JIT/HardwareIntrinsics/General/NotSupported/Vector64BooleanAsUInt64.cs
+++ b/tests/src/JIT/HardwareIntrinsics/General/NotSupported/Vector64BooleanAsUInt64.cs
@@ -35,6 +35,8 @@ private static void Vector64BooleanAsUInt64()
             {
                 TestLibrary.TestFramework.LogInformation($"Vector64BooleanAsUInt64: RunNotSupportedScenario failed to throw NotSupportedException.");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                throw new Exception("One or more scenarios did not complete as expected.");
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/General/NotSupported/Vector64ByteAsGeneric_Boolean.cs b/tests/src/JIT/HardwareIntrinsics/General/NotSupported/Vector64ByteAsGeneric_Boolean.cs
index 08e99655d511..dbd7e8cfe513 100644
--- a/tests/src/JIT/HardwareIntrinsics/General/NotSupported/Vector64ByteAsGeneric_Boolean.cs
+++ b/tests/src/JIT/HardwareIntrinsics/General/NotSupported/Vector64ByteAsGeneric_Boolean.cs
@@ -35,6 +35,8 @@ private static void Vector64ByteAsGeneric_Boolean()
             {
                 TestLibrary.TestFramework.LogInformation($"Vector64ByteAsGeneric_Boolean: RunNotSupportedScenario failed to throw NotSupportedException.");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                throw new Exception("One or more scenarios did not complete as expected.");
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/General/NotSupported/Vector64DoubleAsGeneric_Boolean.cs b/tests/src/JIT/HardwareIntrinsics/General/NotSupported/Vector64DoubleAsGeneric_Boolean.cs
index f9ff44ffc806..257bf0411ffd 100644
--- a/tests/src/JIT/HardwareIntrinsics/General/NotSupported/Vector64DoubleAsGeneric_Boolean.cs
+++ b/tests/src/JIT/HardwareIntrinsics/General/NotSupported/Vector64DoubleAsGeneric_Boolean.cs
@@ -35,6 +35,8 @@ private static void Vector64DoubleAsGeneric_Boolean()
             {
                 TestLibrary.TestFramework.LogInformation($"Vector64DoubleAsGeneric_Boolean: RunNotSupportedScenario failed to throw NotSupportedException.");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                throw new Exception("One or more scenarios did not complete as expected.");
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/General/NotSupported/Vector64GetElement0.cs b/tests/src/JIT/HardwareIntrinsics/General/NotSupported/Vector64GetElement0.cs
index 2055b689f543..9bfa22d94eb6 100644
--- a/tests/src/JIT/HardwareIntrinsics/General/NotSupported/Vector64GetElement0.cs
+++ b/tests/src/JIT/HardwareIntrinsics/General/NotSupported/Vector64GetElement0.cs
@@ -35,6 +35,8 @@ private static void Vector64GetElement0()
             {
                 TestLibrary.TestFramework.LogInformation($"Vector64GetElement0: RunNotSupportedScenario failed to throw NotSupportedException.");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                throw new Exception("One or more scenarios did not complete as expected.");
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/General/NotSupported/Vector64GetElementMaxValue.cs b/tests/src/JIT/HardwareIntrinsics/General/NotSupported/Vector64GetElementMaxValue.cs
index 09414cd1a846..ff51eb99b3d9 100644
--- a/tests/src/JIT/HardwareIntrinsics/General/NotSupported/Vector64GetElementMaxValue.cs
+++ b/tests/src/JIT/HardwareIntrinsics/General/NotSupported/Vector64GetElementMaxValue.cs
@@ -35,6 +35,8 @@ private static void Vector64GetElementMaxValue()
             {
                 TestLibrary.TestFramework.LogInformation($"Vector64GetElementMaxValue: RunNotSupportedScenario failed to throw NotSupportedException.");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                throw new Exception("One or more scenarios did not complete as expected.");
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/General/NotSupported/Vector64GetElementNegativeOne.cs b/tests/src/JIT/HardwareIntrinsics/General/NotSupported/Vector64GetElementNegativeOne.cs
index 4c9da46bb1f9..81a19b478a43 100644
--- a/tests/src/JIT/HardwareIntrinsics/General/NotSupported/Vector64GetElementNegativeOne.cs
+++ b/tests/src/JIT/HardwareIntrinsics/General/NotSupported/Vector64GetElementNegativeOne.cs
@@ -35,6 +35,8 @@ private static void Vector64GetElementNegativeOne()
             {
                 TestLibrary.TestFramework.LogInformation($"Vector64GetElementNegativeOne: RunNotSupportedScenario failed to throw NotSupportedException.");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                throw new Exception("One or more scenarios did not complete as expected.");
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/General/NotSupported/Vector64Int16AsGeneric_Boolean.cs b/tests/src/JIT/HardwareIntrinsics/General/NotSupported/Vector64Int16AsGeneric_Boolean.cs
index e8ef4e75f952..07cdda552588 100644
--- a/tests/src/JIT/HardwareIntrinsics/General/NotSupported/Vector64Int16AsGeneric_Boolean.cs
+++ b/tests/src/JIT/HardwareIntrinsics/General/NotSupported/Vector64Int16AsGeneric_Boolean.cs
@@ -35,6 +35,8 @@ private static void Vector64Int16AsGeneric_Boolean()
             {
                 TestLibrary.TestFramework.LogInformation($"Vector64Int16AsGeneric_Boolean: RunNotSupportedScenario failed to throw NotSupportedException.");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                throw new Exception("One or more scenarios did not complete as expected.");
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/General/NotSupported/Vector64Int32AsGeneric_Boolean.cs b/tests/src/JIT/HardwareIntrinsics/General/NotSupported/Vector64Int32AsGeneric_Boolean.cs
index 25a6e6542a5b..d929ff08dca4 100644
--- a/tests/src/JIT/HardwareIntrinsics/General/NotSupported/Vector64Int32AsGeneric_Boolean.cs
+++ b/tests/src/JIT/HardwareIntrinsics/General/NotSupported/Vector64Int32AsGeneric_Boolean.cs
@@ -35,6 +35,8 @@ private static void Vector64Int32AsGeneric_Boolean()
             {
                 TestLibrary.TestFramework.LogInformation($"Vector64Int32AsGeneric_Boolean: RunNotSupportedScenario failed to throw NotSupportedException.");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                throw new Exception("One or more scenarios did not complete as expected.");
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/General/NotSupported/Vector64Int64AsGeneric_Boolean.cs b/tests/src/JIT/HardwareIntrinsics/General/NotSupported/Vector64Int64AsGeneric_Boolean.cs
index 7ea6752d3d5d..b71f7c251584 100644
--- a/tests/src/JIT/HardwareIntrinsics/General/NotSupported/Vector64Int64AsGeneric_Boolean.cs
+++ b/tests/src/JIT/HardwareIntrinsics/General/NotSupported/Vector64Int64AsGeneric_Boolean.cs
@@ -35,6 +35,8 @@ private static void Vector64Int64AsGeneric_Boolean()
             {
                 TestLibrary.TestFramework.LogInformation($"Vector64Int64AsGeneric_Boolean: RunNotSupportedScenario failed to throw NotSupportedException.");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                throw new Exception("One or more scenarios did not complete as expected.");
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/General/NotSupported/Vector64SByteAsGeneric_Boolean.cs b/tests/src/JIT/HardwareIntrinsics/General/NotSupported/Vector64SByteAsGeneric_Boolean.cs
index 6f3b78db1e7e..504935420e87 100644
--- a/tests/src/JIT/HardwareIntrinsics/General/NotSupported/Vector64SByteAsGeneric_Boolean.cs
+++ b/tests/src/JIT/HardwareIntrinsics/General/NotSupported/Vector64SByteAsGeneric_Boolean.cs
@@ -35,6 +35,8 @@ private static void Vector64SByteAsGeneric_Boolean()
             {
                 TestLibrary.TestFramework.LogInformation($"Vector64SByteAsGeneric_Boolean: RunNotSupportedScenario failed to throw NotSupportedException.");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                throw new Exception("One or more scenarios did not complete as expected.");
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/General/NotSupported/Vector64SingleAsGeneric_Boolean.cs b/tests/src/JIT/HardwareIntrinsics/General/NotSupported/Vector64SingleAsGeneric_Boolean.cs
index a04c618637cc..82d170016a63 100644
--- a/tests/src/JIT/HardwareIntrinsics/General/NotSupported/Vector64SingleAsGeneric_Boolean.cs
+++ b/tests/src/JIT/HardwareIntrinsics/General/NotSupported/Vector64SingleAsGeneric_Boolean.cs
@@ -35,6 +35,8 @@ private static void Vector64SingleAsGeneric_Boolean()
             {
                 TestLibrary.TestFramework.LogInformation($"Vector64SingleAsGeneric_Boolean: RunNotSupportedScenario failed to throw NotSupportedException.");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                throw new Exception("One or more scenarios did not complete as expected.");
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/General/NotSupported/Vector64ToScalar.cs b/tests/src/JIT/HardwareIntrinsics/General/NotSupported/Vector64ToScalar.cs
index fa8efaf23a47..d54a09f795cc 100644
--- a/tests/src/JIT/HardwareIntrinsics/General/NotSupported/Vector64ToScalar.cs
+++ b/tests/src/JIT/HardwareIntrinsics/General/NotSupported/Vector64ToScalar.cs
@@ -35,6 +35,8 @@ private static void Vector64ToScalar()
             {
                 TestLibrary.TestFramework.LogInformation($"Vector64ToScalar: RunNotSupportedScenario failed to throw NotSupportedException.");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                throw new Exception("One or more scenarios did not complete as expected.");
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/General/NotSupported/Vector64ToVector128.cs b/tests/src/JIT/HardwareIntrinsics/General/NotSupported/Vector64ToVector128.cs
index aa52ca68f7d0..45266843d0e1 100644
--- a/tests/src/JIT/HardwareIntrinsics/General/NotSupported/Vector64ToVector128.cs
+++ b/tests/src/JIT/HardwareIntrinsics/General/NotSupported/Vector64ToVector128.cs
@@ -35,6 +35,8 @@ private static void Vector64ToVector128()
             {
                 TestLibrary.TestFramework.LogInformation($"Vector64ToVector128: RunNotSupportedScenario failed to throw NotSupportedException.");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                throw new Exception("One or more scenarios did not complete as expected.");
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/General/NotSupported/Vector64ToVector128Unsafe.cs b/tests/src/JIT/HardwareIntrinsics/General/NotSupported/Vector64ToVector128Unsafe.cs
index 53634ac6aab3..91030507cc22 100644
--- a/tests/src/JIT/HardwareIntrinsics/General/NotSupported/Vector64ToVector128Unsafe.cs
+++ b/tests/src/JIT/HardwareIntrinsics/General/NotSupported/Vector64ToVector128Unsafe.cs
@@ -35,6 +35,8 @@ private static void Vector64ToVector128Unsafe()
             {
                 TestLibrary.TestFramework.LogInformation($"Vector64ToVector128Unsafe: RunNotSupportedScenario failed to throw NotSupportedException.");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                throw new Exception("One or more scenarios did not complete as expected.");
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/General/NotSupported/Vector64UInt16AsGeneric_Boolean.cs b/tests/src/JIT/HardwareIntrinsics/General/NotSupported/Vector64UInt16AsGeneric_Boolean.cs
index fa5ac5e7f266..b86d8c41adbb 100644
--- a/tests/src/JIT/HardwareIntrinsics/General/NotSupported/Vector64UInt16AsGeneric_Boolean.cs
+++ b/tests/src/JIT/HardwareIntrinsics/General/NotSupported/Vector64UInt16AsGeneric_Boolean.cs
@@ -35,6 +35,8 @@ private static void Vector64UInt16AsGeneric_Boolean()
             {
                 TestLibrary.TestFramework.LogInformation($"Vector64UInt16AsGeneric_Boolean: RunNotSupportedScenario failed to throw NotSupportedException.");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                throw new Exception("One or more scenarios did not complete as expected.");
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/General/NotSupported/Vector64UInt32AsGeneric_Boolean.cs b/tests/src/JIT/HardwareIntrinsics/General/NotSupported/Vector64UInt32AsGeneric_Boolean.cs
index 9d478d109f10..01fa2a8dfee1 100644
--- a/tests/src/JIT/HardwareIntrinsics/General/NotSupported/Vector64UInt32AsGeneric_Boolean.cs
+++ b/tests/src/JIT/HardwareIntrinsics/General/NotSupported/Vector64UInt32AsGeneric_Boolean.cs
@@ -35,6 +35,8 @@ private static void Vector64UInt32AsGeneric_Boolean()
             {
                 TestLibrary.TestFramework.LogInformation($"Vector64UInt32AsGeneric_Boolean: RunNotSupportedScenario failed to throw NotSupportedException.");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                throw new Exception("One or more scenarios did not complete as expected.");
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/General/NotSupported/Vector64UInt64AsGeneric_Boolean.cs b/tests/src/JIT/HardwareIntrinsics/General/NotSupported/Vector64UInt64AsGeneric_Boolean.cs
index 3763af860718..282540373c93 100644
--- a/tests/src/JIT/HardwareIntrinsics/General/NotSupported/Vector64UInt64AsGeneric_Boolean.cs
+++ b/tests/src/JIT/HardwareIntrinsics/General/NotSupported/Vector64UInt64AsGeneric_Boolean.cs
@@ -35,6 +35,8 @@ private static void Vector64UInt64AsGeneric_Boolean()
             {
                 TestLibrary.TestFramework.LogInformation($"Vector64UInt64AsGeneric_Boolean: RunNotSupportedScenario failed to throw NotSupportedException.");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                throw new Exception("One or more scenarios did not complete as expected.");
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/General/NotSupported/Vector64WithElement0.cs b/tests/src/JIT/HardwareIntrinsics/General/NotSupported/Vector64WithElement0.cs
index 219dc341ffe0..8200cc9f22a6 100644
--- a/tests/src/JIT/HardwareIntrinsics/General/NotSupported/Vector64WithElement0.cs
+++ b/tests/src/JIT/HardwareIntrinsics/General/NotSupported/Vector64WithElement0.cs
@@ -35,6 +35,8 @@ private static void Vector64WithElement0()
             {
                 TestLibrary.TestFramework.LogInformation($"Vector64WithElement0: RunNotSupportedScenario failed to throw NotSupportedException.");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                throw new Exception("One or more scenarios did not complete as expected.");
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/General/NotSupported/Vector64WithElementMaxValue.cs b/tests/src/JIT/HardwareIntrinsics/General/NotSupported/Vector64WithElementMaxValue.cs
index 747042a6f70e..a38c07336c54 100644
--- a/tests/src/JIT/HardwareIntrinsics/General/NotSupported/Vector64WithElementMaxValue.cs
+++ b/tests/src/JIT/HardwareIntrinsics/General/NotSupported/Vector64WithElementMaxValue.cs
@@ -35,6 +35,8 @@ private static void Vector64WithElementMaxValue()
             {
                 TestLibrary.TestFramework.LogInformation($"Vector64WithElementMaxValue: RunNotSupportedScenario failed to throw NotSupportedException.");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                throw new Exception("One or more scenarios did not complete as expected.");
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/General/NotSupported/Vector64WithElementNegativeOne.cs b/tests/src/JIT/HardwareIntrinsics/General/NotSupported/Vector64WithElementNegativeOne.cs
index ccfc51f6913f..5c23bc290c81 100644
--- a/tests/src/JIT/HardwareIntrinsics/General/NotSupported/Vector64WithElementNegativeOne.cs
+++ b/tests/src/JIT/HardwareIntrinsics/General/NotSupported/Vector64WithElementNegativeOne.cs
@@ -35,6 +35,8 @@ private static void Vector64WithElementNegativeOne()
             {
                 TestLibrary.TestFramework.LogInformation($"Vector64WithElementNegativeOne: RunNotSupportedScenario failed to throw NotSupportedException.");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                throw new Exception("One or more scenarios did not complete as expected.");
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/General/NotSupported/Vector64Zero.cs b/tests/src/JIT/HardwareIntrinsics/General/NotSupported/Vector64Zero.cs
index 9666bcbebb62..10b50bc52483 100644
--- a/tests/src/JIT/HardwareIntrinsics/General/NotSupported/Vector64Zero.cs
+++ b/tests/src/JIT/HardwareIntrinsics/General/NotSupported/Vector64Zero.cs
@@ -35,6 +35,8 @@ private static void Vector64Zero()
             {
                 TestLibrary.TestFramework.LogInformation($"Vector64Zero: RunNotSupportedScenario failed to throw NotSupportedException.");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                throw new Exception("One or more scenarios did not complete as expected.");
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/General/Vector128/Create.Byte.cs b/tests/src/JIT/HardwareIntrinsics/General/Vector128/Create.Byte.cs
index 8b0a69f0d998..6fce9043b947 100644
--- a/tests/src/JIT/HardwareIntrinsics/General/Vector128/Create.Byte.cs
+++ b/tests/src/JIT/HardwareIntrinsics/General/Vector128/Create.Byte.cs
@@ -74,9 +74,11 @@ private void ValidateResult(Vector128<Byte> result, Byte expectedValue, [CallerM
 
         private void ValidateResult(Byte[] resultElements, Byte expectedValue, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (resultElements[0] != expectedValue)
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -84,18 +86,20 @@ private void ValidateResult(Byte[] resultElements, Byte expectedValue, [CallerMe
                 {
                     if (resultElements[i] != expectedValue)
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"Vector128.Create(Byte): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"   value: {expectedValue}");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", resultElements)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/General/Vector128/Create.Double.cs b/tests/src/JIT/HardwareIntrinsics/General/Vector128/Create.Double.cs
index c7d8391d0a46..ca135ccee962 100644
--- a/tests/src/JIT/HardwareIntrinsics/General/Vector128/Create.Double.cs
+++ b/tests/src/JIT/HardwareIntrinsics/General/Vector128/Create.Double.cs
@@ -74,9 +74,11 @@ private void ValidateResult(Vector128<Double> result, Double expectedValue, [Cal
 
         private void ValidateResult(Double[] resultElements, Double expectedValue, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (resultElements[0] != expectedValue)
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -84,18 +86,20 @@ private void ValidateResult(Double[] resultElements, Double expectedValue, [Call
                 {
                     if (resultElements[i] != expectedValue)
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"Vector128.Create(Double): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"   value: {expectedValue}");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", resultElements)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/General/Vector128/Create.Int16.cs b/tests/src/JIT/HardwareIntrinsics/General/Vector128/Create.Int16.cs
index 643711ac6b6c..c7891f2c1afd 100644
--- a/tests/src/JIT/HardwareIntrinsics/General/Vector128/Create.Int16.cs
+++ b/tests/src/JIT/HardwareIntrinsics/General/Vector128/Create.Int16.cs
@@ -74,9 +74,11 @@ private void ValidateResult(Vector128<Int16> result, Int16 expectedValue, [Calle
 
         private void ValidateResult(Int16[] resultElements, Int16 expectedValue, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (resultElements[0] != expectedValue)
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -84,18 +86,20 @@ private void ValidateResult(Int16[] resultElements, Int16 expectedValue, [Caller
                 {
                     if (resultElements[i] != expectedValue)
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"Vector128.Create(Int16): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"   value: {expectedValue}");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", resultElements)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/General/Vector128/Create.Int32.cs b/tests/src/JIT/HardwareIntrinsics/General/Vector128/Create.Int32.cs
index 0b3d64fe0329..c7878834f7ec 100644
--- a/tests/src/JIT/HardwareIntrinsics/General/Vector128/Create.Int32.cs
+++ b/tests/src/JIT/HardwareIntrinsics/General/Vector128/Create.Int32.cs
@@ -74,9 +74,11 @@ private void ValidateResult(Vector128<Int32> result, Int32 expectedValue, [Calle
 
         private void ValidateResult(Int32[] resultElements, Int32 expectedValue, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (resultElements[0] != expectedValue)
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -84,18 +86,20 @@ private void ValidateResult(Int32[] resultElements, Int32 expectedValue, [Caller
                 {
                     if (resultElements[i] != expectedValue)
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"Vector128.Create(Int32): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"   value: {expectedValue}");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", resultElements)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/General/Vector128/Create.Int64.cs b/tests/src/JIT/HardwareIntrinsics/General/Vector128/Create.Int64.cs
index ed992ed3f070..8251b46f71d1 100644
--- a/tests/src/JIT/HardwareIntrinsics/General/Vector128/Create.Int64.cs
+++ b/tests/src/JIT/HardwareIntrinsics/General/Vector128/Create.Int64.cs
@@ -74,9 +74,11 @@ private void ValidateResult(Vector128<Int64> result, Int64 expectedValue, [Calle
 
         private void ValidateResult(Int64[] resultElements, Int64 expectedValue, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (resultElements[0] != expectedValue)
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -84,18 +86,20 @@ private void ValidateResult(Int64[] resultElements, Int64 expectedValue, [Caller
                 {
                     if (resultElements[i] != expectedValue)
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"Vector128.Create(Int64): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"   value: {expectedValue}");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", resultElements)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/General/Vector128/Create.SByte.cs b/tests/src/JIT/HardwareIntrinsics/General/Vector128/Create.SByte.cs
index 80ab8e17c26f..9b9c90610585 100644
--- a/tests/src/JIT/HardwareIntrinsics/General/Vector128/Create.SByte.cs
+++ b/tests/src/JIT/HardwareIntrinsics/General/Vector128/Create.SByte.cs
@@ -74,9 +74,11 @@ private void ValidateResult(Vector128<SByte> result, SByte expectedValue, [Calle
 
         private void ValidateResult(SByte[] resultElements, SByte expectedValue, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (resultElements[0] != expectedValue)
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -84,18 +86,20 @@ private void ValidateResult(SByte[] resultElements, SByte expectedValue, [Caller
                 {
                     if (resultElements[i] != expectedValue)
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"Vector128.Create(SByte): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"   value: {expectedValue}");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", resultElements)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/General/Vector128/Create.Single.cs b/tests/src/JIT/HardwareIntrinsics/General/Vector128/Create.Single.cs
index fbb909d12f77..c9c5606a5510 100644
--- a/tests/src/JIT/HardwareIntrinsics/General/Vector128/Create.Single.cs
+++ b/tests/src/JIT/HardwareIntrinsics/General/Vector128/Create.Single.cs
@@ -74,9 +74,11 @@ private void ValidateResult(Vector128<Single> result, Single expectedValue, [Cal
 
         private void ValidateResult(Single[] resultElements, Single expectedValue, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (resultElements[0] != expectedValue)
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -84,18 +86,20 @@ private void ValidateResult(Single[] resultElements, Single expectedValue, [Call
                 {
                     if (resultElements[i] != expectedValue)
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"Vector128.Create(Single): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"   value: {expectedValue}");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", resultElements)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/General/Vector128/Create.UInt16.cs b/tests/src/JIT/HardwareIntrinsics/General/Vector128/Create.UInt16.cs
index 95e33b197129..c1fb65b1fd43 100644
--- a/tests/src/JIT/HardwareIntrinsics/General/Vector128/Create.UInt16.cs
+++ b/tests/src/JIT/HardwareIntrinsics/General/Vector128/Create.UInt16.cs
@@ -74,9 +74,11 @@ private void ValidateResult(Vector128<UInt16> result, UInt16 expectedValue, [Cal
 
         private void ValidateResult(UInt16[] resultElements, UInt16 expectedValue, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (resultElements[0] != expectedValue)
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -84,18 +86,20 @@ private void ValidateResult(UInt16[] resultElements, UInt16 expectedValue, [Call
                 {
                     if (resultElements[i] != expectedValue)
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"Vector128.Create(UInt16): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"   value: {expectedValue}");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", resultElements)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/General/Vector128/Create.UInt32.cs b/tests/src/JIT/HardwareIntrinsics/General/Vector128/Create.UInt32.cs
index 27e55e3049a7..ebdb390acc24 100644
--- a/tests/src/JIT/HardwareIntrinsics/General/Vector128/Create.UInt32.cs
+++ b/tests/src/JIT/HardwareIntrinsics/General/Vector128/Create.UInt32.cs
@@ -74,9 +74,11 @@ private void ValidateResult(Vector128<UInt32> result, UInt32 expectedValue, [Cal
 
         private void ValidateResult(UInt32[] resultElements, UInt32 expectedValue, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (resultElements[0] != expectedValue)
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -84,18 +86,20 @@ private void ValidateResult(UInt32[] resultElements, UInt32 expectedValue, [Call
                 {
                     if (resultElements[i] != expectedValue)
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"Vector128.Create(UInt32): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"   value: {expectedValue}");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", resultElements)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/General/Vector128/Create.UInt64.cs b/tests/src/JIT/HardwareIntrinsics/General/Vector128/Create.UInt64.cs
index 19a90d53362b..b774df25ee37 100644
--- a/tests/src/JIT/HardwareIntrinsics/General/Vector128/Create.UInt64.cs
+++ b/tests/src/JIT/HardwareIntrinsics/General/Vector128/Create.UInt64.cs
@@ -74,9 +74,11 @@ private void ValidateResult(Vector128<UInt64> result, UInt64 expectedValue, [Cal
 
         private void ValidateResult(UInt64[] resultElements, UInt64 expectedValue, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (resultElements[0] != expectedValue)
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -84,18 +86,20 @@ private void ValidateResult(UInt64[] resultElements, UInt64 expectedValue, [Call
                 {
                     if (resultElements[i] != expectedValue)
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"Vector128.Create(UInt64): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"   value: {expectedValue}");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", resultElements)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/General/Vector128/CreateElement.Byte.cs b/tests/src/JIT/HardwareIntrinsics/General/Vector128/CreateElement.Byte.cs
index 98c7f84df935..5aef59a04f93 100644
--- a/tests/src/JIT/HardwareIntrinsics/General/Vector128/CreateElement.Byte.cs
+++ b/tests/src/JIT/HardwareIntrinsics/General/Vector128/CreateElement.Byte.cs
@@ -88,21 +88,25 @@ private void ValidateResult(Vector128<Byte> result, Byte[] expectedValues, [Call
 
         private void ValidateResult(Byte[] resultElements, Byte[] expectedValues, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             for (var i = 0; i < ElementCount; i++)
             {
                 if (resultElements[i] != expectedValues[i])
                 {
-                    Succeeded = false;
+                    succeeded = false;
                     break;
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"Vector128.Create(Byte): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"   value: ({string.Join(", ", expectedValues)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", resultElements)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/General/Vector128/CreateElement.Double.cs b/tests/src/JIT/HardwareIntrinsics/General/Vector128/CreateElement.Double.cs
index 4cc4acd09741..f6d49053cc5b 100644
--- a/tests/src/JIT/HardwareIntrinsics/General/Vector128/CreateElement.Double.cs
+++ b/tests/src/JIT/HardwareIntrinsics/General/Vector128/CreateElement.Double.cs
@@ -88,21 +88,25 @@ private void ValidateResult(Vector128<Double> result, Double[] expectedValues, [
 
         private void ValidateResult(Double[] resultElements, Double[] expectedValues, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             for (var i = 0; i < ElementCount; i++)
             {
                 if (resultElements[i] != expectedValues[i])
                 {
-                    Succeeded = false;
+                    succeeded = false;
                     break;
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"Vector128.Create(Double): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"   value: ({string.Join(", ", expectedValues)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", resultElements)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/General/Vector128/CreateElement.Int16.cs b/tests/src/JIT/HardwareIntrinsics/General/Vector128/CreateElement.Int16.cs
index 85d143cb1fd3..fee57ccf8284 100644
--- a/tests/src/JIT/HardwareIntrinsics/General/Vector128/CreateElement.Int16.cs
+++ b/tests/src/JIT/HardwareIntrinsics/General/Vector128/CreateElement.Int16.cs
@@ -88,21 +88,25 @@ private void ValidateResult(Vector128<Int16> result, Int16[] expectedValues, [Ca
 
         private void ValidateResult(Int16[] resultElements, Int16[] expectedValues, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             for (var i = 0; i < ElementCount; i++)
             {
                 if (resultElements[i] != expectedValues[i])
                 {
-                    Succeeded = false;
+                    succeeded = false;
                     break;
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"Vector128.Create(Int16): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"   value: ({string.Join(", ", expectedValues)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", resultElements)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/General/Vector128/CreateElement.Int32.cs b/tests/src/JIT/HardwareIntrinsics/General/Vector128/CreateElement.Int32.cs
index 804ab5936108..9fc1a971cbd5 100644
--- a/tests/src/JIT/HardwareIntrinsics/General/Vector128/CreateElement.Int32.cs
+++ b/tests/src/JIT/HardwareIntrinsics/General/Vector128/CreateElement.Int32.cs
@@ -88,21 +88,25 @@ private void ValidateResult(Vector128<Int32> result, Int32[] expectedValues, [Ca
 
         private void ValidateResult(Int32[] resultElements, Int32[] expectedValues, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             for (var i = 0; i < ElementCount; i++)
             {
                 if (resultElements[i] != expectedValues[i])
                 {
-                    Succeeded = false;
+                    succeeded = false;
                     break;
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"Vector128.Create(Int32): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"   value: ({string.Join(", ", expectedValues)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", resultElements)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/General/Vector128/CreateElement.Int64.cs b/tests/src/JIT/HardwareIntrinsics/General/Vector128/CreateElement.Int64.cs
index a63dad623212..a414ea39892d 100644
--- a/tests/src/JIT/HardwareIntrinsics/General/Vector128/CreateElement.Int64.cs
+++ b/tests/src/JIT/HardwareIntrinsics/General/Vector128/CreateElement.Int64.cs
@@ -88,21 +88,25 @@ private void ValidateResult(Vector128<Int64> result, Int64[] expectedValues, [Ca
 
         private void ValidateResult(Int64[] resultElements, Int64[] expectedValues, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             for (var i = 0; i < ElementCount; i++)
             {
                 if (resultElements[i] != expectedValues[i])
                 {
-                    Succeeded = false;
+                    succeeded = false;
                     break;
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"Vector128.Create(Int64): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"   value: ({string.Join(", ", expectedValues)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", resultElements)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/General/Vector128/CreateElement.SByte.cs b/tests/src/JIT/HardwareIntrinsics/General/Vector128/CreateElement.SByte.cs
index 56e7f9502735..851197965e33 100644
--- a/tests/src/JIT/HardwareIntrinsics/General/Vector128/CreateElement.SByte.cs
+++ b/tests/src/JIT/HardwareIntrinsics/General/Vector128/CreateElement.SByte.cs
@@ -88,21 +88,25 @@ private void ValidateResult(Vector128<SByte> result, SByte[] expectedValues, [Ca
 
         private void ValidateResult(SByte[] resultElements, SByte[] expectedValues, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             for (var i = 0; i < ElementCount; i++)
             {
                 if (resultElements[i] != expectedValues[i])
                 {
-                    Succeeded = false;
+                    succeeded = false;
                     break;
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"Vector128.Create(SByte): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"   value: ({string.Join(", ", expectedValues)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", resultElements)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/General/Vector128/CreateElement.Single.cs b/tests/src/JIT/HardwareIntrinsics/General/Vector128/CreateElement.Single.cs
index 74540b3d7eb6..e0f3d871abe7 100644
--- a/tests/src/JIT/HardwareIntrinsics/General/Vector128/CreateElement.Single.cs
+++ b/tests/src/JIT/HardwareIntrinsics/General/Vector128/CreateElement.Single.cs
@@ -88,21 +88,25 @@ private void ValidateResult(Vector128<Single> result, Single[] expectedValues, [
 
         private void ValidateResult(Single[] resultElements, Single[] expectedValues, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             for (var i = 0; i < ElementCount; i++)
             {
                 if (resultElements[i] != expectedValues[i])
                 {
-                    Succeeded = false;
+                    succeeded = false;
                     break;
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"Vector128.Create(Single): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"   value: ({string.Join(", ", expectedValues)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", resultElements)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/General/Vector128/CreateElement.UInt16.cs b/tests/src/JIT/HardwareIntrinsics/General/Vector128/CreateElement.UInt16.cs
index ba89ba0e3c79..f32095827ed3 100644
--- a/tests/src/JIT/HardwareIntrinsics/General/Vector128/CreateElement.UInt16.cs
+++ b/tests/src/JIT/HardwareIntrinsics/General/Vector128/CreateElement.UInt16.cs
@@ -88,21 +88,25 @@ private void ValidateResult(Vector128<UInt16> result, UInt16[] expectedValues, [
 
         private void ValidateResult(UInt16[] resultElements, UInt16[] expectedValues, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             for (var i = 0; i < ElementCount; i++)
             {
                 if (resultElements[i] != expectedValues[i])
                 {
-                    Succeeded = false;
+                    succeeded = false;
                     break;
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"Vector128.Create(UInt16): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"   value: ({string.Join(", ", expectedValues)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", resultElements)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/General/Vector128/CreateElement.UInt32.cs b/tests/src/JIT/HardwareIntrinsics/General/Vector128/CreateElement.UInt32.cs
index 60cec7246570..ab33bc98ad7b 100644
--- a/tests/src/JIT/HardwareIntrinsics/General/Vector128/CreateElement.UInt32.cs
+++ b/tests/src/JIT/HardwareIntrinsics/General/Vector128/CreateElement.UInt32.cs
@@ -88,21 +88,25 @@ private void ValidateResult(Vector128<UInt32> result, UInt32[] expectedValues, [
 
         private void ValidateResult(UInt32[] resultElements, UInt32[] expectedValues, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             for (var i = 0; i < ElementCount; i++)
             {
                 if (resultElements[i] != expectedValues[i])
                 {
-                    Succeeded = false;
+                    succeeded = false;
                     break;
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"Vector128.Create(UInt32): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"   value: ({string.Join(", ", expectedValues)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", resultElements)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/General/Vector128/CreateElement.UInt64.cs b/tests/src/JIT/HardwareIntrinsics/General/Vector128/CreateElement.UInt64.cs
index b437196f3fde..da0dbcf9b134 100644
--- a/tests/src/JIT/HardwareIntrinsics/General/Vector128/CreateElement.UInt64.cs
+++ b/tests/src/JIT/HardwareIntrinsics/General/Vector128/CreateElement.UInt64.cs
@@ -88,21 +88,25 @@ private void ValidateResult(Vector128<UInt64> result, UInt64[] expectedValues, [
 
         private void ValidateResult(UInt64[] resultElements, UInt64[] expectedValues, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             for (var i = 0; i < ElementCount; i++)
             {
                 if (resultElements[i] != expectedValues[i])
                 {
-                    Succeeded = false;
+                    succeeded = false;
                     break;
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"Vector128.Create(UInt64): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"   value: ({string.Join(", ", expectedValues)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", resultElements)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/General/Vector128/CreateScalar.Byte.cs b/tests/src/JIT/HardwareIntrinsics/General/Vector128/CreateScalar.Byte.cs
index 873df6cfb594..22e8a9572122 100644
--- a/tests/src/JIT/HardwareIntrinsics/General/Vector128/CreateScalar.Byte.cs
+++ b/tests/src/JIT/HardwareIntrinsics/General/Vector128/CreateScalar.Byte.cs
@@ -74,9 +74,11 @@ private void ValidateResult(Vector128<Byte> result, Byte expectedValue, [CallerM
 
         private void ValidateResult(Byte[] resultElements, Byte expectedValue, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (resultElements[0] != expectedValue)
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -84,18 +86,20 @@ private void ValidateResult(Byte[] resultElements, Byte expectedValue, [CallerMe
                 {
                     if (resultElements[i] != 0)
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"Vector128.CreateScalar(Byte): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"   value: {expectedValue}");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", resultElements)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/General/Vector128/CreateScalar.Double.cs b/tests/src/JIT/HardwareIntrinsics/General/Vector128/CreateScalar.Double.cs
index c4e2b3cfbde8..e1ae004d06b4 100644
--- a/tests/src/JIT/HardwareIntrinsics/General/Vector128/CreateScalar.Double.cs
+++ b/tests/src/JIT/HardwareIntrinsics/General/Vector128/CreateScalar.Double.cs
@@ -74,9 +74,11 @@ private void ValidateResult(Vector128<Double> result, Double expectedValue, [Cal
 
         private void ValidateResult(Double[] resultElements, Double expectedValue, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (resultElements[0] != expectedValue)
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -84,18 +86,20 @@ private void ValidateResult(Double[] resultElements, Double expectedValue, [Call
                 {
                     if (resultElements[i] != 0)
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"Vector128.CreateScalar(Double): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"   value: {expectedValue}");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", resultElements)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/General/Vector128/CreateScalar.Int16.cs b/tests/src/JIT/HardwareIntrinsics/General/Vector128/CreateScalar.Int16.cs
index cdbca215ae2b..eb131ffc91ce 100644
--- a/tests/src/JIT/HardwareIntrinsics/General/Vector128/CreateScalar.Int16.cs
+++ b/tests/src/JIT/HardwareIntrinsics/General/Vector128/CreateScalar.Int16.cs
@@ -74,9 +74,11 @@ private void ValidateResult(Vector128<Int16> result, Int16 expectedValue, [Calle
 
         private void ValidateResult(Int16[] resultElements, Int16 expectedValue, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (resultElements[0] != expectedValue)
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -84,18 +86,20 @@ private void ValidateResult(Int16[] resultElements, Int16 expectedValue, [Caller
                 {
                     if (resultElements[i] != 0)
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"Vector128.CreateScalar(Int16): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"   value: {expectedValue}");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", resultElements)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/General/Vector128/CreateScalar.Int32.cs b/tests/src/JIT/HardwareIntrinsics/General/Vector128/CreateScalar.Int32.cs
index 7bf566626e14..61bb9c9be1d9 100644
--- a/tests/src/JIT/HardwareIntrinsics/General/Vector128/CreateScalar.Int32.cs
+++ b/tests/src/JIT/HardwareIntrinsics/General/Vector128/CreateScalar.Int32.cs
@@ -74,9 +74,11 @@ private void ValidateResult(Vector128<Int32> result, Int32 expectedValue, [Calle
 
         private void ValidateResult(Int32[] resultElements, Int32 expectedValue, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (resultElements[0] != expectedValue)
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -84,18 +86,20 @@ private void ValidateResult(Int32[] resultElements, Int32 expectedValue, [Caller
                 {
                     if (resultElements[i] != 0)
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"Vector128.CreateScalar(Int32): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"   value: {expectedValue}");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", resultElements)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/General/Vector128/CreateScalar.Int64.cs b/tests/src/JIT/HardwareIntrinsics/General/Vector128/CreateScalar.Int64.cs
index d236a97e8934..43b3f673666c 100644
--- a/tests/src/JIT/HardwareIntrinsics/General/Vector128/CreateScalar.Int64.cs
+++ b/tests/src/JIT/HardwareIntrinsics/General/Vector128/CreateScalar.Int64.cs
@@ -74,9 +74,11 @@ private void ValidateResult(Vector128<Int64> result, Int64 expectedValue, [Calle
 
         private void ValidateResult(Int64[] resultElements, Int64 expectedValue, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (resultElements[0] != expectedValue)
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -84,18 +86,20 @@ private void ValidateResult(Int64[] resultElements, Int64 expectedValue, [Caller
                 {
                     if (resultElements[i] != 0)
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"Vector128.CreateScalar(Int64): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"   value: {expectedValue}");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", resultElements)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/General/Vector128/CreateScalar.SByte.cs b/tests/src/JIT/HardwareIntrinsics/General/Vector128/CreateScalar.SByte.cs
index 0256348e0a99..1475116179fc 100644
--- a/tests/src/JIT/HardwareIntrinsics/General/Vector128/CreateScalar.SByte.cs
+++ b/tests/src/JIT/HardwareIntrinsics/General/Vector128/CreateScalar.SByte.cs
@@ -74,9 +74,11 @@ private void ValidateResult(Vector128<SByte> result, SByte expectedValue, [Calle
 
         private void ValidateResult(SByte[] resultElements, SByte expectedValue, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (resultElements[0] != expectedValue)
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -84,18 +86,20 @@ private void ValidateResult(SByte[] resultElements, SByte expectedValue, [Caller
                 {
                     if (resultElements[i] != 0)
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"Vector128.CreateScalar(SByte): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"   value: {expectedValue}");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", resultElements)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/General/Vector128/CreateScalar.Single.cs b/tests/src/JIT/HardwareIntrinsics/General/Vector128/CreateScalar.Single.cs
index 5b52abb68806..4a4759a99b5e 100644
--- a/tests/src/JIT/HardwareIntrinsics/General/Vector128/CreateScalar.Single.cs
+++ b/tests/src/JIT/HardwareIntrinsics/General/Vector128/CreateScalar.Single.cs
@@ -74,9 +74,11 @@ private void ValidateResult(Vector128<Single> result, Single expectedValue, [Cal
 
         private void ValidateResult(Single[] resultElements, Single expectedValue, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (resultElements[0] != expectedValue)
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -84,18 +86,20 @@ private void ValidateResult(Single[] resultElements, Single expectedValue, [Call
                 {
                     if (resultElements[i] != 0)
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"Vector128.CreateScalar(Single): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"   value: {expectedValue}");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", resultElements)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/General/Vector128/CreateScalar.UInt16.cs b/tests/src/JIT/HardwareIntrinsics/General/Vector128/CreateScalar.UInt16.cs
index 736e414c52aa..e628892db48c 100644
--- a/tests/src/JIT/HardwareIntrinsics/General/Vector128/CreateScalar.UInt16.cs
+++ b/tests/src/JIT/HardwareIntrinsics/General/Vector128/CreateScalar.UInt16.cs
@@ -74,9 +74,11 @@ private void ValidateResult(Vector128<UInt16> result, UInt16 expectedValue, [Cal
 
         private void ValidateResult(UInt16[] resultElements, UInt16 expectedValue, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (resultElements[0] != expectedValue)
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -84,18 +86,20 @@ private void ValidateResult(UInt16[] resultElements, UInt16 expectedValue, [Call
                 {
                     if (resultElements[i] != 0)
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"Vector128.CreateScalar(UInt16): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"   value: {expectedValue}");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", resultElements)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/General/Vector128/CreateScalar.UInt32.cs b/tests/src/JIT/HardwareIntrinsics/General/Vector128/CreateScalar.UInt32.cs
index f873d37a2311..be3fa869d93a 100644
--- a/tests/src/JIT/HardwareIntrinsics/General/Vector128/CreateScalar.UInt32.cs
+++ b/tests/src/JIT/HardwareIntrinsics/General/Vector128/CreateScalar.UInt32.cs
@@ -74,9 +74,11 @@ private void ValidateResult(Vector128<UInt32> result, UInt32 expectedValue, [Cal
 
         private void ValidateResult(UInt32[] resultElements, UInt32 expectedValue, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (resultElements[0] != expectedValue)
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -84,18 +86,20 @@ private void ValidateResult(UInt32[] resultElements, UInt32 expectedValue, [Call
                 {
                     if (resultElements[i] != 0)
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"Vector128.CreateScalar(UInt32): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"   value: {expectedValue}");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", resultElements)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/General/Vector128/CreateScalar.UInt64.cs b/tests/src/JIT/HardwareIntrinsics/General/Vector128/CreateScalar.UInt64.cs
index 1047a74aad6c..02ec93d08bfc 100644
--- a/tests/src/JIT/HardwareIntrinsics/General/Vector128/CreateScalar.UInt64.cs
+++ b/tests/src/JIT/HardwareIntrinsics/General/Vector128/CreateScalar.UInt64.cs
@@ -74,9 +74,11 @@ private void ValidateResult(Vector128<UInt64> result, UInt64 expectedValue, [Cal
 
         private void ValidateResult(UInt64[] resultElements, UInt64 expectedValue, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (resultElements[0] != expectedValue)
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -84,18 +86,20 @@ private void ValidateResult(UInt64[] resultElements, UInt64 expectedValue, [Call
                 {
                     if (resultElements[i] != 0)
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"Vector128.CreateScalar(UInt64): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"   value: {expectedValue}");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", resultElements)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/General/Vector128/CreateScalarUnsafe.Byte.cs b/tests/src/JIT/HardwareIntrinsics/General/Vector128/CreateScalarUnsafe.Byte.cs
index b6b48729a126..5dc33f1ee676 100644
--- a/tests/src/JIT/HardwareIntrinsics/General/Vector128/CreateScalarUnsafe.Byte.cs
+++ b/tests/src/JIT/HardwareIntrinsics/General/Vector128/CreateScalarUnsafe.Byte.cs
@@ -74,9 +74,11 @@ private void ValidateResult(Vector128<Byte> result, Byte expectedValue, [CallerM
 
         private void ValidateResult(Byte[] resultElements, Byte expectedValue, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (resultElements[0] != expectedValue)
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -84,18 +86,20 @@ private void ValidateResult(Byte[] resultElements, Byte expectedValue, [CallerMe
                 {
                     if (false /* value is uninitialized */)
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"Vector128.CreateScalarUnsafe(Byte): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"   value: {expectedValue}");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", resultElements)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/General/Vector128/CreateScalarUnsafe.Double.cs b/tests/src/JIT/HardwareIntrinsics/General/Vector128/CreateScalarUnsafe.Double.cs
index 6d90e84b0aa7..bad0e4e83552 100644
--- a/tests/src/JIT/HardwareIntrinsics/General/Vector128/CreateScalarUnsafe.Double.cs
+++ b/tests/src/JIT/HardwareIntrinsics/General/Vector128/CreateScalarUnsafe.Double.cs
@@ -74,9 +74,11 @@ private void ValidateResult(Vector128<Double> result, Double expectedValue, [Cal
 
         private void ValidateResult(Double[] resultElements, Double expectedValue, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (resultElements[0] != expectedValue)
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -84,18 +86,20 @@ private void ValidateResult(Double[] resultElements, Double expectedValue, [Call
                 {
                     if (false /* value is uninitialized */)
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"Vector128.CreateScalarUnsafe(Double): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"   value: {expectedValue}");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", resultElements)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/General/Vector128/CreateScalarUnsafe.Int16.cs b/tests/src/JIT/HardwareIntrinsics/General/Vector128/CreateScalarUnsafe.Int16.cs
index de0b4f25ec9b..883753480d94 100644
--- a/tests/src/JIT/HardwareIntrinsics/General/Vector128/CreateScalarUnsafe.Int16.cs
+++ b/tests/src/JIT/HardwareIntrinsics/General/Vector128/CreateScalarUnsafe.Int16.cs
@@ -74,9 +74,11 @@ private void ValidateResult(Vector128<Int16> result, Int16 expectedValue, [Calle
 
         private void ValidateResult(Int16[] resultElements, Int16 expectedValue, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (resultElements[0] != expectedValue)
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -84,18 +86,20 @@ private void ValidateResult(Int16[] resultElements, Int16 expectedValue, [Caller
                 {
                     if (false /* value is uninitialized */)
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"Vector128.CreateScalarUnsafe(Int16): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"   value: {expectedValue}");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", resultElements)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/General/Vector128/CreateScalarUnsafe.Int32.cs b/tests/src/JIT/HardwareIntrinsics/General/Vector128/CreateScalarUnsafe.Int32.cs
index 79fe4e36ff02..288a134ed645 100644
--- a/tests/src/JIT/HardwareIntrinsics/General/Vector128/CreateScalarUnsafe.Int32.cs
+++ b/tests/src/JIT/HardwareIntrinsics/General/Vector128/CreateScalarUnsafe.Int32.cs
@@ -74,9 +74,11 @@ private void ValidateResult(Vector128<Int32> result, Int32 expectedValue, [Calle
 
         private void ValidateResult(Int32[] resultElements, Int32 expectedValue, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (resultElements[0] != expectedValue)
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -84,18 +86,20 @@ private void ValidateResult(Int32[] resultElements, Int32 expectedValue, [Caller
                 {
                     if (false /* value is uninitialized */)
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"Vector128.CreateScalarUnsafe(Int32): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"   value: {expectedValue}");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", resultElements)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/General/Vector128/CreateScalarUnsafe.Int64.cs b/tests/src/JIT/HardwareIntrinsics/General/Vector128/CreateScalarUnsafe.Int64.cs
index c45a48449a25..ea5508be3412 100644
--- a/tests/src/JIT/HardwareIntrinsics/General/Vector128/CreateScalarUnsafe.Int64.cs
+++ b/tests/src/JIT/HardwareIntrinsics/General/Vector128/CreateScalarUnsafe.Int64.cs
@@ -74,9 +74,11 @@ private void ValidateResult(Vector128<Int64> result, Int64 expectedValue, [Calle
 
         private void ValidateResult(Int64[] resultElements, Int64 expectedValue, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (resultElements[0] != expectedValue)
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -84,18 +86,20 @@ private void ValidateResult(Int64[] resultElements, Int64 expectedValue, [Caller
                 {
                     if (false /* value is uninitialized */)
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"Vector128.CreateScalarUnsafe(Int64): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"   value: {expectedValue}");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", resultElements)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/General/Vector128/CreateScalarUnsafe.SByte.cs b/tests/src/JIT/HardwareIntrinsics/General/Vector128/CreateScalarUnsafe.SByte.cs
index 3555d7a90046..b3a3489d197d 100644
--- a/tests/src/JIT/HardwareIntrinsics/General/Vector128/CreateScalarUnsafe.SByte.cs
+++ b/tests/src/JIT/HardwareIntrinsics/General/Vector128/CreateScalarUnsafe.SByte.cs
@@ -74,9 +74,11 @@ private void ValidateResult(Vector128<SByte> result, SByte expectedValue, [Calle
 
         private void ValidateResult(SByte[] resultElements, SByte expectedValue, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (resultElements[0] != expectedValue)
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -84,18 +86,20 @@ private void ValidateResult(SByte[] resultElements, SByte expectedValue, [Caller
                 {
                     if (false /* value is uninitialized */)
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"Vector128.CreateScalarUnsafe(SByte): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"   value: {expectedValue}");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", resultElements)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/General/Vector128/CreateScalarUnsafe.Single.cs b/tests/src/JIT/HardwareIntrinsics/General/Vector128/CreateScalarUnsafe.Single.cs
index c4b1a59aa61a..ce9664c58b2a 100644
--- a/tests/src/JIT/HardwareIntrinsics/General/Vector128/CreateScalarUnsafe.Single.cs
+++ b/tests/src/JIT/HardwareIntrinsics/General/Vector128/CreateScalarUnsafe.Single.cs
@@ -74,9 +74,11 @@ private void ValidateResult(Vector128<Single> result, Single expectedValue, [Cal
 
         private void ValidateResult(Single[] resultElements, Single expectedValue, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (resultElements[0] != expectedValue)
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -84,18 +86,20 @@ private void ValidateResult(Single[] resultElements, Single expectedValue, [Call
                 {
                     if (false /* value is uninitialized */)
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"Vector128.CreateScalarUnsafe(Single): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"   value: {expectedValue}");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", resultElements)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/General/Vector128/CreateScalarUnsafe.UInt16.cs b/tests/src/JIT/HardwareIntrinsics/General/Vector128/CreateScalarUnsafe.UInt16.cs
index c1b17fb9d020..a2ca916c85ad 100644
--- a/tests/src/JIT/HardwareIntrinsics/General/Vector128/CreateScalarUnsafe.UInt16.cs
+++ b/tests/src/JIT/HardwareIntrinsics/General/Vector128/CreateScalarUnsafe.UInt16.cs
@@ -74,9 +74,11 @@ private void ValidateResult(Vector128<UInt16> result, UInt16 expectedValue, [Cal
 
         private void ValidateResult(UInt16[] resultElements, UInt16 expectedValue, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (resultElements[0] != expectedValue)
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -84,18 +86,20 @@ private void ValidateResult(UInt16[] resultElements, UInt16 expectedValue, [Call
                 {
                     if (false /* value is uninitialized */)
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"Vector128.CreateScalarUnsafe(UInt16): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"   value: {expectedValue}");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", resultElements)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/General/Vector128/CreateScalarUnsafe.UInt32.cs b/tests/src/JIT/HardwareIntrinsics/General/Vector128/CreateScalarUnsafe.UInt32.cs
index 8c31d4461b29..44742fb8867a 100644
--- a/tests/src/JIT/HardwareIntrinsics/General/Vector128/CreateScalarUnsafe.UInt32.cs
+++ b/tests/src/JIT/HardwareIntrinsics/General/Vector128/CreateScalarUnsafe.UInt32.cs
@@ -74,9 +74,11 @@ private void ValidateResult(Vector128<UInt32> result, UInt32 expectedValue, [Cal
 
         private void ValidateResult(UInt32[] resultElements, UInt32 expectedValue, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (resultElements[0] != expectedValue)
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -84,18 +86,20 @@ private void ValidateResult(UInt32[] resultElements, UInt32 expectedValue, [Call
                 {
                     if (false /* value is uninitialized */)
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"Vector128.CreateScalarUnsafe(UInt32): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"   value: {expectedValue}");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", resultElements)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/General/Vector128/CreateScalarUnsafe.UInt64.cs b/tests/src/JIT/HardwareIntrinsics/General/Vector128/CreateScalarUnsafe.UInt64.cs
index f2e3e03f8094..572175f36e22 100644
--- a/tests/src/JIT/HardwareIntrinsics/General/Vector128/CreateScalarUnsafe.UInt64.cs
+++ b/tests/src/JIT/HardwareIntrinsics/General/Vector128/CreateScalarUnsafe.UInt64.cs
@@ -74,9 +74,11 @@ private void ValidateResult(Vector128<UInt64> result, UInt64 expectedValue, [Cal
 
         private void ValidateResult(UInt64[] resultElements, UInt64 expectedValue, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (resultElements[0] != expectedValue)
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -84,18 +86,20 @@ private void ValidateResult(UInt64[] resultElements, UInt64 expectedValue, [Call
                 {
                     if (false /* value is uninitialized */)
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"Vector128.CreateScalarUnsafe(UInt64): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"   value: {expectedValue}");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", resultElements)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/General/Vector128/CreateVector.Byte.cs b/tests/src/JIT/HardwareIntrinsics/General/Vector128/CreateVector.Byte.cs
index 8423bb9246b3..fee5002f83d6 100644
--- a/tests/src/JIT/HardwareIntrinsics/General/Vector128/CreateVector.Byte.cs
+++ b/tests/src/JIT/HardwareIntrinsics/General/Vector128/CreateVector.Byte.cs
@@ -84,11 +84,13 @@ private void ValidateResult(Vector128<Byte> result, Byte expectedLowerValue, Byt
 
         private void ValidateResult(Byte[] resultElements, Byte expectedLowerValue, Byte expectedUpperValue, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             for (var i = 0; i < ElementCount / 2; i++)
             {
                 if (resultElements[i] != expectedLowerValue)
                 {
-                    Succeeded = false;
+                    succeeded = false;
                     break;
                 }
             }
@@ -97,18 +99,20 @@ private void ValidateResult(Byte[] resultElements, Byte expectedLowerValue, Byte
             {
                 if (resultElements[i] != expectedUpperValue)
                 {
-                    Succeeded = false;
+                    succeeded = false;
                     break;
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"Vector128.Create(Byte): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"   lower: {expectedLowerValue}");
                 TestLibrary.TestFramework.LogInformation($"   upper: {expectedUpperValue}");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", resultElements)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/General/Vector128/CreateVector.Double.cs b/tests/src/JIT/HardwareIntrinsics/General/Vector128/CreateVector.Double.cs
index 7cd70b163ffe..ce42868bf17c 100644
--- a/tests/src/JIT/HardwareIntrinsics/General/Vector128/CreateVector.Double.cs
+++ b/tests/src/JIT/HardwareIntrinsics/General/Vector128/CreateVector.Double.cs
@@ -84,11 +84,13 @@ private void ValidateResult(Vector128<Double> result, Double expectedLowerValue,
 
         private void ValidateResult(Double[] resultElements, Double expectedLowerValue, Double expectedUpperValue, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             for (var i = 0; i < ElementCount / 2; i++)
             {
                 if (resultElements[i] != expectedLowerValue)
                 {
-                    Succeeded = false;
+                    succeeded = false;
                     break;
                 }
             }
@@ -97,18 +99,20 @@ private void ValidateResult(Double[] resultElements, Double expectedLowerValue,
             {
                 if (resultElements[i] != expectedUpperValue)
                 {
-                    Succeeded = false;
+                    succeeded = false;
                     break;
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"Vector128.Create(Double): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"   lower: {expectedLowerValue}");
                 TestLibrary.TestFramework.LogInformation($"   upper: {expectedUpperValue}");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", resultElements)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/General/Vector128/CreateVector.Int16.cs b/tests/src/JIT/HardwareIntrinsics/General/Vector128/CreateVector.Int16.cs
index 748305920fa1..f1257a379e4e 100644
--- a/tests/src/JIT/HardwareIntrinsics/General/Vector128/CreateVector.Int16.cs
+++ b/tests/src/JIT/HardwareIntrinsics/General/Vector128/CreateVector.Int16.cs
@@ -84,11 +84,13 @@ private void ValidateResult(Vector128<Int16> result, Int16 expectedLowerValue, I
 
         private void ValidateResult(Int16[] resultElements, Int16 expectedLowerValue, Int16 expectedUpperValue, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             for (var i = 0; i < ElementCount / 2; i++)
             {
                 if (resultElements[i] != expectedLowerValue)
                 {
-                    Succeeded = false;
+                    succeeded = false;
                     break;
                 }
             }
@@ -97,18 +99,20 @@ private void ValidateResult(Int16[] resultElements, Int16 expectedLowerValue, In
             {
                 if (resultElements[i] != expectedUpperValue)
                 {
-                    Succeeded = false;
+                    succeeded = false;
                     break;
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"Vector128.Create(Int16): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"   lower: {expectedLowerValue}");
                 TestLibrary.TestFramework.LogInformation($"   upper: {expectedUpperValue}");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", resultElements)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/General/Vector128/CreateVector.Int32.cs b/tests/src/JIT/HardwareIntrinsics/General/Vector128/CreateVector.Int32.cs
index df0f4ba74358..5dfd86fb5d57 100644
--- a/tests/src/JIT/HardwareIntrinsics/General/Vector128/CreateVector.Int32.cs
+++ b/tests/src/JIT/HardwareIntrinsics/General/Vector128/CreateVector.Int32.cs
@@ -84,11 +84,13 @@ private void ValidateResult(Vector128<Int32> result, Int32 expectedLowerValue, I
 
         private void ValidateResult(Int32[] resultElements, Int32 expectedLowerValue, Int32 expectedUpperValue, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             for (var i = 0; i < ElementCount / 2; i++)
             {
                 if (resultElements[i] != expectedLowerValue)
                 {
-                    Succeeded = false;
+                    succeeded = false;
                     break;
                 }
             }
@@ -97,18 +99,20 @@ private void ValidateResult(Int32[] resultElements, Int32 expectedLowerValue, In
             {
                 if (resultElements[i] != expectedUpperValue)
                 {
-                    Succeeded = false;
+                    succeeded = false;
                     break;
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"Vector128.Create(Int32): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"   lower: {expectedLowerValue}");
                 TestLibrary.TestFramework.LogInformation($"   upper: {expectedUpperValue}");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", resultElements)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/General/Vector128/CreateVector.Int64.cs b/tests/src/JIT/HardwareIntrinsics/General/Vector128/CreateVector.Int64.cs
index cb18564e88ad..44882579f368 100644
--- a/tests/src/JIT/HardwareIntrinsics/General/Vector128/CreateVector.Int64.cs
+++ b/tests/src/JIT/HardwareIntrinsics/General/Vector128/CreateVector.Int64.cs
@@ -84,11 +84,13 @@ private void ValidateResult(Vector128<Int64> result, Int64 expectedLowerValue, I
 
         private void ValidateResult(Int64[] resultElements, Int64 expectedLowerValue, Int64 expectedUpperValue, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             for (var i = 0; i < ElementCount / 2; i++)
             {
                 if (resultElements[i] != expectedLowerValue)
                 {
-                    Succeeded = false;
+                    succeeded = false;
                     break;
                 }
             }
@@ -97,18 +99,20 @@ private void ValidateResult(Int64[] resultElements, Int64 expectedLowerValue, In
             {
                 if (resultElements[i] != expectedUpperValue)
                 {
-                    Succeeded = false;
+                    succeeded = false;
                     break;
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"Vector128.Create(Int64): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"   lower: {expectedLowerValue}");
                 TestLibrary.TestFramework.LogInformation($"   upper: {expectedUpperValue}");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", resultElements)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/General/Vector128/CreateVector.SByte.cs b/tests/src/JIT/HardwareIntrinsics/General/Vector128/CreateVector.SByte.cs
index 65fdbe6d524f..686565a9b96d 100644
--- a/tests/src/JIT/HardwareIntrinsics/General/Vector128/CreateVector.SByte.cs
+++ b/tests/src/JIT/HardwareIntrinsics/General/Vector128/CreateVector.SByte.cs
@@ -84,11 +84,13 @@ private void ValidateResult(Vector128<SByte> result, SByte expectedLowerValue, S
 
         private void ValidateResult(SByte[] resultElements, SByte expectedLowerValue, SByte expectedUpperValue, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             for (var i = 0; i < ElementCount / 2; i++)
             {
                 if (resultElements[i] != expectedLowerValue)
                 {
-                    Succeeded = false;
+                    succeeded = false;
                     break;
                 }
             }
@@ -97,18 +99,20 @@ private void ValidateResult(SByte[] resultElements, SByte expectedLowerValue, SB
             {
                 if (resultElements[i] != expectedUpperValue)
                 {
-                    Succeeded = false;
+                    succeeded = false;
                     break;
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"Vector128.Create(SByte): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"   lower: {expectedLowerValue}");
                 TestLibrary.TestFramework.LogInformation($"   upper: {expectedUpperValue}");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", resultElements)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/General/Vector128/CreateVector.Single.cs b/tests/src/JIT/HardwareIntrinsics/General/Vector128/CreateVector.Single.cs
index 4c07257d27e0..23dc7d6583a2 100644
--- a/tests/src/JIT/HardwareIntrinsics/General/Vector128/CreateVector.Single.cs
+++ b/tests/src/JIT/HardwareIntrinsics/General/Vector128/CreateVector.Single.cs
@@ -84,11 +84,13 @@ private void ValidateResult(Vector128<Single> result, Single expectedLowerValue,
 
         private void ValidateResult(Single[] resultElements, Single expectedLowerValue, Single expectedUpperValue, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             for (var i = 0; i < ElementCount / 2; i++)
             {
                 if (resultElements[i] != expectedLowerValue)
                 {
-                    Succeeded = false;
+                    succeeded = false;
                     break;
                 }
             }
@@ -97,18 +99,20 @@ private void ValidateResult(Single[] resultElements, Single expectedLowerValue,
             {
                 if (resultElements[i] != expectedUpperValue)
                 {
-                    Succeeded = false;
+                    succeeded = false;
                     break;
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"Vector128.Create(Single): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"   lower: {expectedLowerValue}");
                 TestLibrary.TestFramework.LogInformation($"   upper: {expectedUpperValue}");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", resultElements)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/General/Vector128/CreateVector.UInt16.cs b/tests/src/JIT/HardwareIntrinsics/General/Vector128/CreateVector.UInt16.cs
index c74ee8404f1e..eaca06522cc2 100644
--- a/tests/src/JIT/HardwareIntrinsics/General/Vector128/CreateVector.UInt16.cs
+++ b/tests/src/JIT/HardwareIntrinsics/General/Vector128/CreateVector.UInt16.cs
@@ -84,11 +84,13 @@ private void ValidateResult(Vector128<UInt16> result, UInt16 expectedLowerValue,
 
         private void ValidateResult(UInt16[] resultElements, UInt16 expectedLowerValue, UInt16 expectedUpperValue, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             for (var i = 0; i < ElementCount / 2; i++)
             {
                 if (resultElements[i] != expectedLowerValue)
                 {
-                    Succeeded = false;
+                    succeeded = false;
                     break;
                 }
             }
@@ -97,18 +99,20 @@ private void ValidateResult(UInt16[] resultElements, UInt16 expectedLowerValue,
             {
                 if (resultElements[i] != expectedUpperValue)
                 {
-                    Succeeded = false;
+                    succeeded = false;
                     break;
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"Vector128.Create(UInt16): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"   lower: {expectedLowerValue}");
                 TestLibrary.TestFramework.LogInformation($"   upper: {expectedUpperValue}");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", resultElements)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/General/Vector128/CreateVector.UInt32.cs b/tests/src/JIT/HardwareIntrinsics/General/Vector128/CreateVector.UInt32.cs
index 66687bfc77e9..721bceae4df6 100644
--- a/tests/src/JIT/HardwareIntrinsics/General/Vector128/CreateVector.UInt32.cs
+++ b/tests/src/JIT/HardwareIntrinsics/General/Vector128/CreateVector.UInt32.cs
@@ -84,11 +84,13 @@ private void ValidateResult(Vector128<UInt32> result, UInt32 expectedLowerValue,
 
         private void ValidateResult(UInt32[] resultElements, UInt32 expectedLowerValue, UInt32 expectedUpperValue, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             for (var i = 0; i < ElementCount / 2; i++)
             {
                 if (resultElements[i] != expectedLowerValue)
                 {
-                    Succeeded = false;
+                    succeeded = false;
                     break;
                 }
             }
@@ -97,18 +99,20 @@ private void ValidateResult(UInt32[] resultElements, UInt32 expectedLowerValue,
             {
                 if (resultElements[i] != expectedUpperValue)
                 {
-                    Succeeded = false;
+                    succeeded = false;
                     break;
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"Vector128.Create(UInt32): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"   lower: {expectedLowerValue}");
                 TestLibrary.TestFramework.LogInformation($"   upper: {expectedUpperValue}");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", resultElements)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/General/Vector128/CreateVector.UInt64.cs b/tests/src/JIT/HardwareIntrinsics/General/Vector128/CreateVector.UInt64.cs
index 8720d7dbe773..61f6316e116a 100644
--- a/tests/src/JIT/HardwareIntrinsics/General/Vector128/CreateVector.UInt64.cs
+++ b/tests/src/JIT/HardwareIntrinsics/General/Vector128/CreateVector.UInt64.cs
@@ -84,11 +84,13 @@ private void ValidateResult(Vector128<UInt64> result, UInt64 expectedLowerValue,
 
         private void ValidateResult(UInt64[] resultElements, UInt64 expectedLowerValue, UInt64 expectedUpperValue, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             for (var i = 0; i < ElementCount / 2; i++)
             {
                 if (resultElements[i] != expectedLowerValue)
                 {
-                    Succeeded = false;
+                    succeeded = false;
                     break;
                 }
             }
@@ -97,18 +99,20 @@ private void ValidateResult(UInt64[] resultElements, UInt64 expectedLowerValue,
             {
                 if (resultElements[i] != expectedUpperValue)
                 {
-                    Succeeded = false;
+                    succeeded = false;
                     break;
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"Vector128.Create(UInt64): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"   lower: {expectedLowerValue}");
                 TestLibrary.TestFramework.LogInformation($"   upper: {expectedUpperValue}");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", resultElements)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/General/Vector128_1/As.Byte.cs b/tests/src/JIT/HardwareIntrinsics/General/Vector128_1/As.Byte.cs
index 01394c6810b6..01f4d61a3a80 100644
--- a/tests/src/JIT/HardwareIntrinsics/General/Vector128_1/As.Byte.cs
+++ b/tests/src/JIT/HardwareIntrinsics/General/Vector128_1/As.Byte.cs
@@ -218,21 +218,25 @@ private void ValidateResult<T>(Vector128<T> result, Vector128<Byte> value, [Call
 
         private void ValidateResult(Byte[] resultElements, Byte[] valueElements, Type targetType, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             for (var i = 0; i < ElementCount; i++)
             {
                 if (resultElements[i] != valueElements[i])
                 {
-                    Succeeded = false;
+                    succeeded = false;
                     break;
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"Vector128<Byte>.As{targetType.Name}: {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"   value: ({string.Join(", ", valueElements)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", resultElements)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/General/Vector128_1/As.Double.cs b/tests/src/JIT/HardwareIntrinsics/General/Vector128_1/As.Double.cs
index 7f4538cb5d2c..81c61460c712 100644
--- a/tests/src/JIT/HardwareIntrinsics/General/Vector128_1/As.Double.cs
+++ b/tests/src/JIT/HardwareIntrinsics/General/Vector128_1/As.Double.cs
@@ -218,21 +218,25 @@ private void ValidateResult<T>(Vector128<T> result, Vector128<Double> value, [Ca
 
         private void ValidateResult(Double[] resultElements, Double[] valueElements, Type targetType, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             for (var i = 0; i < ElementCount; i++)
             {
                 if (resultElements[i] != valueElements[i])
                 {
-                    Succeeded = false;
+                    succeeded = false;
                     break;
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"Vector128<Double>.As{targetType.Name}: {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"   value: ({string.Join(", ", valueElements)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", resultElements)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/General/Vector128_1/As.Int16.cs b/tests/src/JIT/HardwareIntrinsics/General/Vector128_1/As.Int16.cs
index ec8bbf74335c..282af64305af 100644
--- a/tests/src/JIT/HardwareIntrinsics/General/Vector128_1/As.Int16.cs
+++ b/tests/src/JIT/HardwareIntrinsics/General/Vector128_1/As.Int16.cs
@@ -218,21 +218,25 @@ private void ValidateResult<T>(Vector128<T> result, Vector128<Int16> value, [Cal
 
         private void ValidateResult(Int16[] resultElements, Int16[] valueElements, Type targetType, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             for (var i = 0; i < ElementCount; i++)
             {
                 if (resultElements[i] != valueElements[i])
                 {
-                    Succeeded = false;
+                    succeeded = false;
                     break;
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"Vector128<Int16>.As{targetType.Name}: {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"   value: ({string.Join(", ", valueElements)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", resultElements)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/General/Vector128_1/As.Int32.cs b/tests/src/JIT/HardwareIntrinsics/General/Vector128_1/As.Int32.cs
index 233cf35c08f9..b028d731a92f 100644
--- a/tests/src/JIT/HardwareIntrinsics/General/Vector128_1/As.Int32.cs
+++ b/tests/src/JIT/HardwareIntrinsics/General/Vector128_1/As.Int32.cs
@@ -218,21 +218,25 @@ private void ValidateResult<T>(Vector128<T> result, Vector128<Int32> value, [Cal
 
         private void ValidateResult(Int32[] resultElements, Int32[] valueElements, Type targetType, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             for (var i = 0; i < ElementCount; i++)
             {
                 if (resultElements[i] != valueElements[i])
                 {
-                    Succeeded = false;
+                    succeeded = false;
                     break;
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"Vector128<Int32>.As{targetType.Name}: {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"   value: ({string.Join(", ", valueElements)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", resultElements)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/General/Vector128_1/As.Int64.cs b/tests/src/JIT/HardwareIntrinsics/General/Vector128_1/As.Int64.cs
index 320c6d920d68..ed9b1789ef54 100644
--- a/tests/src/JIT/HardwareIntrinsics/General/Vector128_1/As.Int64.cs
+++ b/tests/src/JIT/HardwareIntrinsics/General/Vector128_1/As.Int64.cs
@@ -218,21 +218,25 @@ private void ValidateResult<T>(Vector128<T> result, Vector128<Int64> value, [Cal
 
         private void ValidateResult(Int64[] resultElements, Int64[] valueElements, Type targetType, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             for (var i = 0; i < ElementCount; i++)
             {
                 if (resultElements[i] != valueElements[i])
                 {
-                    Succeeded = false;
+                    succeeded = false;
                     break;
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"Vector128<Int64>.As{targetType.Name}: {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"   value: ({string.Join(", ", valueElements)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", resultElements)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/General/Vector128_1/As.SByte.cs b/tests/src/JIT/HardwareIntrinsics/General/Vector128_1/As.SByte.cs
index e3068dc9dcc3..9d0aaf96e061 100644
--- a/tests/src/JIT/HardwareIntrinsics/General/Vector128_1/As.SByte.cs
+++ b/tests/src/JIT/HardwareIntrinsics/General/Vector128_1/As.SByte.cs
@@ -218,21 +218,25 @@ private void ValidateResult<T>(Vector128<T> result, Vector128<SByte> value, [Cal
 
         private void ValidateResult(SByte[] resultElements, SByte[] valueElements, Type targetType, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             for (var i = 0; i < ElementCount; i++)
             {
                 if (resultElements[i] != valueElements[i])
                 {
-                    Succeeded = false;
+                    succeeded = false;
                     break;
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"Vector128<SByte>.As{targetType.Name}: {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"   value: ({string.Join(", ", valueElements)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", resultElements)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/General/Vector128_1/As.Single.cs b/tests/src/JIT/HardwareIntrinsics/General/Vector128_1/As.Single.cs
index 7dd18eb1fc96..cea215872cbe 100644
--- a/tests/src/JIT/HardwareIntrinsics/General/Vector128_1/As.Single.cs
+++ b/tests/src/JIT/HardwareIntrinsics/General/Vector128_1/As.Single.cs
@@ -218,21 +218,25 @@ private void ValidateResult<T>(Vector128<T> result, Vector128<Single> value, [Ca
 
         private void ValidateResult(Single[] resultElements, Single[] valueElements, Type targetType, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             for (var i = 0; i < ElementCount; i++)
             {
                 if (resultElements[i] != valueElements[i])
                 {
-                    Succeeded = false;
+                    succeeded = false;
                     break;
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"Vector128<Single>.As{targetType.Name}: {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"   value: ({string.Join(", ", valueElements)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", resultElements)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/General/Vector128_1/As.UInt16.cs b/tests/src/JIT/HardwareIntrinsics/General/Vector128_1/As.UInt16.cs
index 09870f15a5e8..a06c5f8d11a0 100644
--- a/tests/src/JIT/HardwareIntrinsics/General/Vector128_1/As.UInt16.cs
+++ b/tests/src/JIT/HardwareIntrinsics/General/Vector128_1/As.UInt16.cs
@@ -218,21 +218,25 @@ private void ValidateResult<T>(Vector128<T> result, Vector128<UInt16> value, [Ca
 
         private void ValidateResult(UInt16[] resultElements, UInt16[] valueElements, Type targetType, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             for (var i = 0; i < ElementCount; i++)
             {
                 if (resultElements[i] != valueElements[i])
                 {
-                    Succeeded = false;
+                    succeeded = false;
                     break;
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"Vector128<UInt16>.As{targetType.Name}: {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"   value: ({string.Join(", ", valueElements)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", resultElements)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/General/Vector128_1/As.UInt32.cs b/tests/src/JIT/HardwareIntrinsics/General/Vector128_1/As.UInt32.cs
index cff2f3531266..190b8b8e74f7 100644
--- a/tests/src/JIT/HardwareIntrinsics/General/Vector128_1/As.UInt32.cs
+++ b/tests/src/JIT/HardwareIntrinsics/General/Vector128_1/As.UInt32.cs
@@ -218,21 +218,25 @@ private void ValidateResult<T>(Vector128<T> result, Vector128<UInt32> value, [Ca
 
         private void ValidateResult(UInt32[] resultElements, UInt32[] valueElements, Type targetType, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             for (var i = 0; i < ElementCount; i++)
             {
                 if (resultElements[i] != valueElements[i])
                 {
-                    Succeeded = false;
+                    succeeded = false;
                     break;
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"Vector128<UInt32>.As{targetType.Name}: {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"   value: ({string.Join(", ", valueElements)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", resultElements)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/General/Vector128_1/As.UInt64.cs b/tests/src/JIT/HardwareIntrinsics/General/Vector128_1/As.UInt64.cs
index bc9004e1605b..1b48d48a2798 100644
--- a/tests/src/JIT/HardwareIntrinsics/General/Vector128_1/As.UInt64.cs
+++ b/tests/src/JIT/HardwareIntrinsics/General/Vector128_1/As.UInt64.cs
@@ -218,21 +218,25 @@ private void ValidateResult<T>(Vector128<T> result, Vector128<UInt64> value, [Ca
 
         private void ValidateResult(UInt64[] resultElements, UInt64[] valueElements, Type targetType, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             for (var i = 0; i < ElementCount; i++)
             {
                 if (resultElements[i] != valueElements[i])
                 {
-                    Succeeded = false;
+                    succeeded = false;
                     break;
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"Vector128<UInt64>.As{targetType.Name}: {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"   value: ({string.Join(", ", valueElements)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", resultElements)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/General/Vector128_1/GetAndWithElement.Byte.0.cs b/tests/src/JIT/HardwareIntrinsics/General/Vector128_1/GetAndWithElement.Byte.0.cs
index 7c6381a43eb0..3bd1fd9c4eda 100644
--- a/tests/src/JIT/HardwareIntrinsics/General/Vector128_1/GetAndWithElement.Byte.0.cs
+++ b/tests/src/JIT/HardwareIntrinsics/General/Vector128_1/GetAndWithElement.Byte.0.cs
@@ -74,10 +74,10 @@ public void RunBasicScenario(int imm = 0, bool expectedOutOfRangeException = fal
 
             if (!succeeded)
             {
-                Succeeded = false;
-
                 TestLibrary.TestFramework.LogInformation($"Vector128<Byte.GetElement({imm}): {nameof(RunBasicScenario)} failed to throw ArgumentOutOfRangeException.");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
 
             succeeded = !expectedOutOfRangeException;
@@ -96,10 +96,10 @@ public void RunBasicScenario(int imm = 0, bool expectedOutOfRangeException = fal
 
             if (!succeeded)
             {
-                Succeeded = false;
-
                 TestLibrary.TestFramework.LogInformation($"Vector128<Byte.WithElement({imm}): {nameof(RunBasicScenario)} failed to throw ArgumentOutOfRangeException.");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
 
@@ -133,10 +133,10 @@ public void RunReflectionScenario(int imm = 0, bool expectedOutOfRangeException
 
             if (!succeeded)
             {
-                Succeeded = false;
-
                 TestLibrary.TestFramework.LogInformation($"Vector128<Byte.GetElement({imm}): {nameof(RunReflectionScenario)} failed to throw ArgumentOutOfRangeException.");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
 
             succeeded = !expectedOutOfRangeException;
@@ -158,10 +158,10 @@ public void RunReflectionScenario(int imm = 0, bool expectedOutOfRangeException
 
             if (!succeeded)
             {
-                Succeeded = false;
-
                 TestLibrary.TestFramework.LogInformation($"Vector128<Byte.WithElement({imm}): {nameof(RunReflectionScenario)} failed to throw ArgumentOutOfRangeException.");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
 
@@ -196,27 +196,31 @@ private void ValidateWithResult(Vector128<Byte> result, Byte[] values, Byte inse
 
         private void ValidateWithResult(Byte[] result, Byte[] values, Byte insertedValue, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             for (int i = 0; i < ElementCount; i++)
             {
                 if ((i != 0) && (result[i] != values[i]))
                 {
-                    Succeeded = false;
+                    succeeded = false;
                     break;
                 }
             }
 
             if (result[0] != insertedValue)
             {
-                Succeeded = false;
+                succeeded = false;
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"Vector128<Byte.WithElement(0): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"   value: ({string.Join(", ", values)})");
                 TestLibrary.TestFramework.LogInformation($"  insert: insertedValue");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/General/Vector128_1/GetAndWithElement.Byte.15.cs b/tests/src/JIT/HardwareIntrinsics/General/Vector128_1/GetAndWithElement.Byte.15.cs
index e3cf31716238..d8a4c250c2b3 100644
--- a/tests/src/JIT/HardwareIntrinsics/General/Vector128_1/GetAndWithElement.Byte.15.cs
+++ b/tests/src/JIT/HardwareIntrinsics/General/Vector128_1/GetAndWithElement.Byte.15.cs
@@ -74,10 +74,10 @@ public void RunBasicScenario(int imm = 15, bool expectedOutOfRangeException = fa
 
             if (!succeeded)
             {
-                Succeeded = false;
-
                 TestLibrary.TestFramework.LogInformation($"Vector128<Byte.GetElement({imm}): {nameof(RunBasicScenario)} failed to throw ArgumentOutOfRangeException.");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
 
             succeeded = !expectedOutOfRangeException;
@@ -96,10 +96,10 @@ public void RunBasicScenario(int imm = 15, bool expectedOutOfRangeException = fa
 
             if (!succeeded)
             {
-                Succeeded = false;
-
                 TestLibrary.TestFramework.LogInformation($"Vector128<Byte.WithElement({imm}): {nameof(RunBasicScenario)} failed to throw ArgumentOutOfRangeException.");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
 
@@ -133,10 +133,10 @@ public void RunReflectionScenario(int imm = 15, bool expectedOutOfRangeException
 
             if (!succeeded)
             {
-                Succeeded = false;
-
                 TestLibrary.TestFramework.LogInformation($"Vector128<Byte.GetElement({imm}): {nameof(RunReflectionScenario)} failed to throw ArgumentOutOfRangeException.");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
 
             succeeded = !expectedOutOfRangeException;
@@ -158,10 +158,10 @@ public void RunReflectionScenario(int imm = 15, bool expectedOutOfRangeException
 
             if (!succeeded)
             {
-                Succeeded = false;
-
                 TestLibrary.TestFramework.LogInformation($"Vector128<Byte.WithElement({imm}): {nameof(RunReflectionScenario)} failed to throw ArgumentOutOfRangeException.");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
 
@@ -196,27 +196,31 @@ private void ValidateWithResult(Vector128<Byte> result, Byte[] values, Byte inse
 
         private void ValidateWithResult(Byte[] result, Byte[] values, Byte insertedValue, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             for (int i = 0; i < ElementCount; i++)
             {
                 if ((i != 15) && (result[i] != values[i]))
                 {
-                    Succeeded = false;
+                    succeeded = false;
                     break;
                 }
             }
 
             if (result[15] != insertedValue)
             {
-                Succeeded = false;
+                succeeded = false;
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"Vector128<Byte.WithElement(15): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"   value: ({string.Join(", ", values)})");
                 TestLibrary.TestFramework.LogInformation($"  insert: insertedValue");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/General/Vector128_1/GetAndWithElement.Byte.7.cs b/tests/src/JIT/HardwareIntrinsics/General/Vector128_1/GetAndWithElement.Byte.7.cs
index b72c50375dbb..9204dfe113fb 100644
--- a/tests/src/JIT/HardwareIntrinsics/General/Vector128_1/GetAndWithElement.Byte.7.cs
+++ b/tests/src/JIT/HardwareIntrinsics/General/Vector128_1/GetAndWithElement.Byte.7.cs
@@ -74,10 +74,10 @@ public void RunBasicScenario(int imm = 7, bool expectedOutOfRangeException = fal
 
             if (!succeeded)
             {
-                Succeeded = false;
-
                 TestLibrary.TestFramework.LogInformation($"Vector128<Byte.GetElement({imm}): {nameof(RunBasicScenario)} failed to throw ArgumentOutOfRangeException.");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
 
             succeeded = !expectedOutOfRangeException;
@@ -96,10 +96,10 @@ public void RunBasicScenario(int imm = 7, bool expectedOutOfRangeException = fal
 
             if (!succeeded)
             {
-                Succeeded = false;
-
                 TestLibrary.TestFramework.LogInformation($"Vector128<Byte.WithElement({imm}): {nameof(RunBasicScenario)} failed to throw ArgumentOutOfRangeException.");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
 
@@ -133,10 +133,10 @@ public void RunReflectionScenario(int imm = 7, bool expectedOutOfRangeException
 
             if (!succeeded)
             {
-                Succeeded = false;
-
                 TestLibrary.TestFramework.LogInformation($"Vector128<Byte.GetElement({imm}): {nameof(RunReflectionScenario)} failed to throw ArgumentOutOfRangeException.");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
 
             succeeded = !expectedOutOfRangeException;
@@ -158,10 +158,10 @@ public void RunReflectionScenario(int imm = 7, bool expectedOutOfRangeException
 
             if (!succeeded)
             {
-                Succeeded = false;
-
                 TestLibrary.TestFramework.LogInformation($"Vector128<Byte.WithElement({imm}): {nameof(RunReflectionScenario)} failed to throw ArgumentOutOfRangeException.");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
 
@@ -196,27 +196,31 @@ private void ValidateWithResult(Vector128<Byte> result, Byte[] values, Byte inse
 
         private void ValidateWithResult(Byte[] result, Byte[] values, Byte insertedValue, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             for (int i = 0; i < ElementCount; i++)
             {
                 if ((i != 7) && (result[i] != values[i]))
                 {
-                    Succeeded = false;
+                    succeeded = false;
                     break;
                 }
             }
 
             if (result[7] != insertedValue)
             {
-                Succeeded = false;
+                succeeded = false;
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"Vector128<Byte.WithElement(7): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"   value: ({string.Join(", ", values)})");
                 TestLibrary.TestFramework.LogInformation($"  insert: insertedValue");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/General/Vector128_1/GetAndWithElement.Double.0.cs b/tests/src/JIT/HardwareIntrinsics/General/Vector128_1/GetAndWithElement.Double.0.cs
index d5f592c9a8e0..e008bf6f848a 100644
--- a/tests/src/JIT/HardwareIntrinsics/General/Vector128_1/GetAndWithElement.Double.0.cs
+++ b/tests/src/JIT/HardwareIntrinsics/General/Vector128_1/GetAndWithElement.Double.0.cs
@@ -74,10 +74,10 @@ public void RunBasicScenario(int imm = 0, bool expectedOutOfRangeException = fal
 
             if (!succeeded)
             {
-                Succeeded = false;
-
                 TestLibrary.TestFramework.LogInformation($"Vector128<Double.GetElement({imm}): {nameof(RunBasicScenario)} failed to throw ArgumentOutOfRangeException.");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
 
             succeeded = !expectedOutOfRangeException;
@@ -96,10 +96,10 @@ public void RunBasicScenario(int imm = 0, bool expectedOutOfRangeException = fal
 
             if (!succeeded)
             {
-                Succeeded = false;
-
                 TestLibrary.TestFramework.LogInformation($"Vector128<Double.WithElement({imm}): {nameof(RunBasicScenario)} failed to throw ArgumentOutOfRangeException.");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
 
@@ -133,10 +133,10 @@ public void RunReflectionScenario(int imm = 0, bool expectedOutOfRangeException
 
             if (!succeeded)
             {
-                Succeeded = false;
-
                 TestLibrary.TestFramework.LogInformation($"Vector128<Double.GetElement({imm}): {nameof(RunReflectionScenario)} failed to throw ArgumentOutOfRangeException.");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
 
             succeeded = !expectedOutOfRangeException;
@@ -158,10 +158,10 @@ public void RunReflectionScenario(int imm = 0, bool expectedOutOfRangeException
 
             if (!succeeded)
             {
-                Succeeded = false;
-
                 TestLibrary.TestFramework.LogInformation($"Vector128<Double.WithElement({imm}): {nameof(RunReflectionScenario)} failed to throw ArgumentOutOfRangeException.");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
 
@@ -196,27 +196,31 @@ private void ValidateWithResult(Vector128<Double> result, Double[] values, Doubl
 
         private void ValidateWithResult(Double[] result, Double[] values, Double insertedValue, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             for (int i = 0; i < ElementCount; i++)
             {
                 if ((i != 0) && (result[i] != values[i]))
                 {
-                    Succeeded = false;
+                    succeeded = false;
                     break;
                 }
             }
 
             if (result[0] != insertedValue)
             {
-                Succeeded = false;
+                succeeded = false;
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"Vector128<Double.WithElement(0): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"   value: ({string.Join(", ", values)})");
                 TestLibrary.TestFramework.LogInformation($"  insert: insertedValue");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/General/Vector128_1/GetAndWithElement.Double.1.cs b/tests/src/JIT/HardwareIntrinsics/General/Vector128_1/GetAndWithElement.Double.1.cs
index 29d00ee39662..8f686217838b 100644
--- a/tests/src/JIT/HardwareIntrinsics/General/Vector128_1/GetAndWithElement.Double.1.cs
+++ b/tests/src/JIT/HardwareIntrinsics/General/Vector128_1/GetAndWithElement.Double.1.cs
@@ -74,10 +74,10 @@ public void RunBasicScenario(int imm = 1, bool expectedOutOfRangeException = fal
 
             if (!succeeded)
             {
-                Succeeded = false;
-
                 TestLibrary.TestFramework.LogInformation($"Vector128<Double.GetElement({imm}): {nameof(RunBasicScenario)} failed to throw ArgumentOutOfRangeException.");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
 
             succeeded = !expectedOutOfRangeException;
@@ -96,10 +96,10 @@ public void RunBasicScenario(int imm = 1, bool expectedOutOfRangeException = fal
 
             if (!succeeded)
             {
-                Succeeded = false;
-
                 TestLibrary.TestFramework.LogInformation($"Vector128<Double.WithElement({imm}): {nameof(RunBasicScenario)} failed to throw ArgumentOutOfRangeException.");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
 
@@ -133,10 +133,10 @@ public void RunReflectionScenario(int imm = 1, bool expectedOutOfRangeException
 
             if (!succeeded)
             {
-                Succeeded = false;
-
                 TestLibrary.TestFramework.LogInformation($"Vector128<Double.GetElement({imm}): {nameof(RunReflectionScenario)} failed to throw ArgumentOutOfRangeException.");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
 
             succeeded = !expectedOutOfRangeException;
@@ -158,10 +158,10 @@ public void RunReflectionScenario(int imm = 1, bool expectedOutOfRangeException
 
             if (!succeeded)
             {
-                Succeeded = false;
-
                 TestLibrary.TestFramework.LogInformation($"Vector128<Double.WithElement({imm}): {nameof(RunReflectionScenario)} failed to throw ArgumentOutOfRangeException.");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
 
@@ -196,27 +196,31 @@ private void ValidateWithResult(Vector128<Double> result, Double[] values, Doubl
 
         private void ValidateWithResult(Double[] result, Double[] values, Double insertedValue, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             for (int i = 0; i < ElementCount; i++)
             {
                 if ((i != 1) && (result[i] != values[i]))
                 {
-                    Succeeded = false;
+                    succeeded = false;
                     break;
                 }
             }
 
             if (result[1] != insertedValue)
             {
-                Succeeded = false;
+                succeeded = false;
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"Vector128<Double.WithElement(1): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"   value: ({string.Join(", ", values)})");
                 TestLibrary.TestFramework.LogInformation($"  insert: insertedValue");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/General/Vector128_1/GetAndWithElement.Int16.0.cs b/tests/src/JIT/HardwareIntrinsics/General/Vector128_1/GetAndWithElement.Int16.0.cs
index 86ad9c62a471..e9d3205e155d 100644
--- a/tests/src/JIT/HardwareIntrinsics/General/Vector128_1/GetAndWithElement.Int16.0.cs
+++ b/tests/src/JIT/HardwareIntrinsics/General/Vector128_1/GetAndWithElement.Int16.0.cs
@@ -74,10 +74,10 @@ public void RunBasicScenario(int imm = 0, bool expectedOutOfRangeException = fal
 
             if (!succeeded)
             {
-                Succeeded = false;
-
                 TestLibrary.TestFramework.LogInformation($"Vector128<Int16.GetElement({imm}): {nameof(RunBasicScenario)} failed to throw ArgumentOutOfRangeException.");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
 
             succeeded = !expectedOutOfRangeException;
@@ -96,10 +96,10 @@ public void RunBasicScenario(int imm = 0, bool expectedOutOfRangeException = fal
 
             if (!succeeded)
             {
-                Succeeded = false;
-
                 TestLibrary.TestFramework.LogInformation($"Vector128<Int16.WithElement({imm}): {nameof(RunBasicScenario)} failed to throw ArgumentOutOfRangeException.");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
 
@@ -133,10 +133,10 @@ public void RunReflectionScenario(int imm = 0, bool expectedOutOfRangeException
 
             if (!succeeded)
             {
-                Succeeded = false;
-
                 TestLibrary.TestFramework.LogInformation($"Vector128<Int16.GetElement({imm}): {nameof(RunReflectionScenario)} failed to throw ArgumentOutOfRangeException.");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
 
             succeeded = !expectedOutOfRangeException;
@@ -158,10 +158,10 @@ public void RunReflectionScenario(int imm = 0, bool expectedOutOfRangeException
 
             if (!succeeded)
             {
-                Succeeded = false;
-
                 TestLibrary.TestFramework.LogInformation($"Vector128<Int16.WithElement({imm}): {nameof(RunReflectionScenario)} failed to throw ArgumentOutOfRangeException.");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
 
@@ -196,27 +196,31 @@ private void ValidateWithResult(Vector128<Int16> result, Int16[] values, Int16 i
 
         private void ValidateWithResult(Int16[] result, Int16[] values, Int16 insertedValue, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             for (int i = 0; i < ElementCount; i++)
             {
                 if ((i != 0) && (result[i] != values[i]))
                 {
-                    Succeeded = false;
+                    succeeded = false;
                     break;
                 }
             }
 
             if (result[0] != insertedValue)
             {
-                Succeeded = false;
+                succeeded = false;
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"Vector128<Int16.WithElement(0): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"   value: ({string.Join(", ", values)})");
                 TestLibrary.TestFramework.LogInformation($"  insert: insertedValue");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/General/Vector128_1/GetAndWithElement.Int16.3.cs b/tests/src/JIT/HardwareIntrinsics/General/Vector128_1/GetAndWithElement.Int16.3.cs
index 22315c12a65b..b865bbb2c526 100644
--- a/tests/src/JIT/HardwareIntrinsics/General/Vector128_1/GetAndWithElement.Int16.3.cs
+++ b/tests/src/JIT/HardwareIntrinsics/General/Vector128_1/GetAndWithElement.Int16.3.cs
@@ -74,10 +74,10 @@ public void RunBasicScenario(int imm = 3, bool expectedOutOfRangeException = fal
 
             if (!succeeded)
             {
-                Succeeded = false;
-
                 TestLibrary.TestFramework.LogInformation($"Vector128<Int16.GetElement({imm}): {nameof(RunBasicScenario)} failed to throw ArgumentOutOfRangeException.");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
 
             succeeded = !expectedOutOfRangeException;
@@ -96,10 +96,10 @@ public void RunBasicScenario(int imm = 3, bool expectedOutOfRangeException = fal
 
             if (!succeeded)
             {
-                Succeeded = false;
-
                 TestLibrary.TestFramework.LogInformation($"Vector128<Int16.WithElement({imm}): {nameof(RunBasicScenario)} failed to throw ArgumentOutOfRangeException.");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
 
@@ -133,10 +133,10 @@ public void RunReflectionScenario(int imm = 3, bool expectedOutOfRangeException
 
             if (!succeeded)
             {
-                Succeeded = false;
-
                 TestLibrary.TestFramework.LogInformation($"Vector128<Int16.GetElement({imm}): {nameof(RunReflectionScenario)} failed to throw ArgumentOutOfRangeException.");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
 
             succeeded = !expectedOutOfRangeException;
@@ -158,10 +158,10 @@ public void RunReflectionScenario(int imm = 3, bool expectedOutOfRangeException
 
             if (!succeeded)
             {
-                Succeeded = false;
-
                 TestLibrary.TestFramework.LogInformation($"Vector128<Int16.WithElement({imm}): {nameof(RunReflectionScenario)} failed to throw ArgumentOutOfRangeException.");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
 
@@ -196,27 +196,31 @@ private void ValidateWithResult(Vector128<Int16> result, Int16[] values, Int16 i
 
         private void ValidateWithResult(Int16[] result, Int16[] values, Int16 insertedValue, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             for (int i = 0; i < ElementCount; i++)
             {
                 if ((i != 3) && (result[i] != values[i]))
                 {
-                    Succeeded = false;
+                    succeeded = false;
                     break;
                 }
             }
 
             if (result[3] != insertedValue)
             {
-                Succeeded = false;
+                succeeded = false;
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"Vector128<Int16.WithElement(3): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"   value: ({string.Join(", ", values)})");
                 TestLibrary.TestFramework.LogInformation($"  insert: insertedValue");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/General/Vector128_1/GetAndWithElement.Int16.7.cs b/tests/src/JIT/HardwareIntrinsics/General/Vector128_1/GetAndWithElement.Int16.7.cs
index 3f81ddd09e70..c487a2a20cba 100644
--- a/tests/src/JIT/HardwareIntrinsics/General/Vector128_1/GetAndWithElement.Int16.7.cs
+++ b/tests/src/JIT/HardwareIntrinsics/General/Vector128_1/GetAndWithElement.Int16.7.cs
@@ -74,10 +74,10 @@ public void RunBasicScenario(int imm = 7, bool expectedOutOfRangeException = fal
 
             if (!succeeded)
             {
-                Succeeded = false;
-
                 TestLibrary.TestFramework.LogInformation($"Vector128<Int16.GetElement({imm}): {nameof(RunBasicScenario)} failed to throw ArgumentOutOfRangeException.");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
 
             succeeded = !expectedOutOfRangeException;
@@ -96,10 +96,10 @@ public void RunBasicScenario(int imm = 7, bool expectedOutOfRangeException = fal
 
             if (!succeeded)
             {
-                Succeeded = false;
-
                 TestLibrary.TestFramework.LogInformation($"Vector128<Int16.WithElement({imm}): {nameof(RunBasicScenario)} failed to throw ArgumentOutOfRangeException.");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
 
@@ -133,10 +133,10 @@ public void RunReflectionScenario(int imm = 7, bool expectedOutOfRangeException
 
             if (!succeeded)
             {
-                Succeeded = false;
-
                 TestLibrary.TestFramework.LogInformation($"Vector128<Int16.GetElement({imm}): {nameof(RunReflectionScenario)} failed to throw ArgumentOutOfRangeException.");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
 
             succeeded = !expectedOutOfRangeException;
@@ -158,10 +158,10 @@ public void RunReflectionScenario(int imm = 7, bool expectedOutOfRangeException
 
             if (!succeeded)
             {
-                Succeeded = false;
-
                 TestLibrary.TestFramework.LogInformation($"Vector128<Int16.WithElement({imm}): {nameof(RunReflectionScenario)} failed to throw ArgumentOutOfRangeException.");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
 
@@ -196,27 +196,31 @@ private void ValidateWithResult(Vector128<Int16> result, Int16[] values, Int16 i
 
         private void ValidateWithResult(Int16[] result, Int16[] values, Int16 insertedValue, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             for (int i = 0; i < ElementCount; i++)
             {
                 if ((i != 7) && (result[i] != values[i]))
                 {
-                    Succeeded = false;
+                    succeeded = false;
                     break;
                 }
             }
 
             if (result[7] != insertedValue)
             {
-                Succeeded = false;
+                succeeded = false;
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"Vector128<Int16.WithElement(7): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"   value: ({string.Join(", ", values)})");
                 TestLibrary.TestFramework.LogInformation($"  insert: insertedValue");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/General/Vector128_1/GetAndWithElement.Int32.0.cs b/tests/src/JIT/HardwareIntrinsics/General/Vector128_1/GetAndWithElement.Int32.0.cs
index 7753c7d6dba4..f71557cf65cb 100644
--- a/tests/src/JIT/HardwareIntrinsics/General/Vector128_1/GetAndWithElement.Int32.0.cs
+++ b/tests/src/JIT/HardwareIntrinsics/General/Vector128_1/GetAndWithElement.Int32.0.cs
@@ -74,10 +74,10 @@ public void RunBasicScenario(int imm = 0, bool expectedOutOfRangeException = fal
 
             if (!succeeded)
             {
-                Succeeded = false;
-
                 TestLibrary.TestFramework.LogInformation($"Vector128<Int32.GetElement({imm}): {nameof(RunBasicScenario)} failed to throw ArgumentOutOfRangeException.");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
 
             succeeded = !expectedOutOfRangeException;
@@ -96,10 +96,10 @@ public void RunBasicScenario(int imm = 0, bool expectedOutOfRangeException = fal
 
             if (!succeeded)
             {
-                Succeeded = false;
-
                 TestLibrary.TestFramework.LogInformation($"Vector128<Int32.WithElement({imm}): {nameof(RunBasicScenario)} failed to throw ArgumentOutOfRangeException.");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
 
@@ -133,10 +133,10 @@ public void RunReflectionScenario(int imm = 0, bool expectedOutOfRangeException
 
             if (!succeeded)
             {
-                Succeeded = false;
-
                 TestLibrary.TestFramework.LogInformation($"Vector128<Int32.GetElement({imm}): {nameof(RunReflectionScenario)} failed to throw ArgumentOutOfRangeException.");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
 
             succeeded = !expectedOutOfRangeException;
@@ -158,10 +158,10 @@ public void RunReflectionScenario(int imm = 0, bool expectedOutOfRangeException
 
             if (!succeeded)
             {
-                Succeeded = false;
-
                 TestLibrary.TestFramework.LogInformation($"Vector128<Int32.WithElement({imm}): {nameof(RunReflectionScenario)} failed to throw ArgumentOutOfRangeException.");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
 
@@ -196,27 +196,31 @@ private void ValidateWithResult(Vector128<Int32> result, Int32[] values, Int32 i
 
         private void ValidateWithResult(Int32[] result, Int32[] values, Int32 insertedValue, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             for (int i = 0; i < ElementCount; i++)
             {
                 if ((i != 0) && (result[i] != values[i]))
                 {
-                    Succeeded = false;
+                    succeeded = false;
                     break;
                 }
             }
 
             if (result[0] != insertedValue)
             {
-                Succeeded = false;
+                succeeded = false;
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"Vector128<Int32.WithElement(0): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"   value: ({string.Join(", ", values)})");
                 TestLibrary.TestFramework.LogInformation($"  insert: insertedValue");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/General/Vector128_1/GetAndWithElement.Int32.1.cs b/tests/src/JIT/HardwareIntrinsics/General/Vector128_1/GetAndWithElement.Int32.1.cs
index 0c1a8945fe52..75968b0bdf5d 100644
--- a/tests/src/JIT/HardwareIntrinsics/General/Vector128_1/GetAndWithElement.Int32.1.cs
+++ b/tests/src/JIT/HardwareIntrinsics/General/Vector128_1/GetAndWithElement.Int32.1.cs
@@ -74,10 +74,10 @@ public void RunBasicScenario(int imm = 1, bool expectedOutOfRangeException = fal
 
             if (!succeeded)
             {
-                Succeeded = false;
-
                 TestLibrary.TestFramework.LogInformation($"Vector128<Int32.GetElement({imm}): {nameof(RunBasicScenario)} failed to throw ArgumentOutOfRangeException.");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
 
             succeeded = !expectedOutOfRangeException;
@@ -96,10 +96,10 @@ public void RunBasicScenario(int imm = 1, bool expectedOutOfRangeException = fal
 
             if (!succeeded)
             {
-                Succeeded = false;
-
                 TestLibrary.TestFramework.LogInformation($"Vector128<Int32.WithElement({imm}): {nameof(RunBasicScenario)} failed to throw ArgumentOutOfRangeException.");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
 
@@ -133,10 +133,10 @@ public void RunReflectionScenario(int imm = 1, bool expectedOutOfRangeException
 
             if (!succeeded)
             {
-                Succeeded = false;
-
                 TestLibrary.TestFramework.LogInformation($"Vector128<Int32.GetElement({imm}): {nameof(RunReflectionScenario)} failed to throw ArgumentOutOfRangeException.");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
 
             succeeded = !expectedOutOfRangeException;
@@ -158,10 +158,10 @@ public void RunReflectionScenario(int imm = 1, bool expectedOutOfRangeException
 
             if (!succeeded)
             {
-                Succeeded = false;
-
                 TestLibrary.TestFramework.LogInformation($"Vector128<Int32.WithElement({imm}): {nameof(RunReflectionScenario)} failed to throw ArgumentOutOfRangeException.");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
 
@@ -196,27 +196,31 @@ private void ValidateWithResult(Vector128<Int32> result, Int32[] values, Int32 i
 
         private void ValidateWithResult(Int32[] result, Int32[] values, Int32 insertedValue, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             for (int i = 0; i < ElementCount; i++)
             {
                 if ((i != 1) && (result[i] != values[i]))
                 {
-                    Succeeded = false;
+                    succeeded = false;
                     break;
                 }
             }
 
             if (result[1] != insertedValue)
             {
-                Succeeded = false;
+                succeeded = false;
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"Vector128<Int32.WithElement(1): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"   value: ({string.Join(", ", values)})");
                 TestLibrary.TestFramework.LogInformation($"  insert: insertedValue");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/General/Vector128_1/GetAndWithElement.Int32.3.cs b/tests/src/JIT/HardwareIntrinsics/General/Vector128_1/GetAndWithElement.Int32.3.cs
index ba8d9b9bf86c..ac67c752de95 100644
--- a/tests/src/JIT/HardwareIntrinsics/General/Vector128_1/GetAndWithElement.Int32.3.cs
+++ b/tests/src/JIT/HardwareIntrinsics/General/Vector128_1/GetAndWithElement.Int32.3.cs
@@ -74,10 +74,10 @@ public void RunBasicScenario(int imm = 3, bool expectedOutOfRangeException = fal
 
             if (!succeeded)
             {
-                Succeeded = false;
-
                 TestLibrary.TestFramework.LogInformation($"Vector128<Int32.GetElement({imm}): {nameof(RunBasicScenario)} failed to throw ArgumentOutOfRangeException.");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
 
             succeeded = !expectedOutOfRangeException;
@@ -96,10 +96,10 @@ public void RunBasicScenario(int imm = 3, bool expectedOutOfRangeException = fal
 
             if (!succeeded)
             {
-                Succeeded = false;
-
                 TestLibrary.TestFramework.LogInformation($"Vector128<Int32.WithElement({imm}): {nameof(RunBasicScenario)} failed to throw ArgumentOutOfRangeException.");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
 
@@ -133,10 +133,10 @@ public void RunReflectionScenario(int imm = 3, bool expectedOutOfRangeException
 
             if (!succeeded)
             {
-                Succeeded = false;
-
                 TestLibrary.TestFramework.LogInformation($"Vector128<Int32.GetElement({imm}): {nameof(RunReflectionScenario)} failed to throw ArgumentOutOfRangeException.");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
 
             succeeded = !expectedOutOfRangeException;
@@ -158,10 +158,10 @@ public void RunReflectionScenario(int imm = 3, bool expectedOutOfRangeException
 
             if (!succeeded)
             {
-                Succeeded = false;
-
                 TestLibrary.TestFramework.LogInformation($"Vector128<Int32.WithElement({imm}): {nameof(RunReflectionScenario)} failed to throw ArgumentOutOfRangeException.");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
 
@@ -196,27 +196,31 @@ private void ValidateWithResult(Vector128<Int32> result, Int32[] values, Int32 i
 
         private void ValidateWithResult(Int32[] result, Int32[] values, Int32 insertedValue, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             for (int i = 0; i < ElementCount; i++)
             {
                 if ((i != 3) && (result[i] != values[i]))
                 {
-                    Succeeded = false;
+                    succeeded = false;
                     break;
                 }
             }
 
             if (result[3] != insertedValue)
             {
-                Succeeded = false;
+                succeeded = false;
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"Vector128<Int32.WithElement(3): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"   value: ({string.Join(", ", values)})");
                 TestLibrary.TestFramework.LogInformation($"  insert: insertedValue");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/General/Vector128_1/GetAndWithElement.Int64.0.cs b/tests/src/JIT/HardwareIntrinsics/General/Vector128_1/GetAndWithElement.Int64.0.cs
index 0271ba7ebace..425b00c2ae88 100644
--- a/tests/src/JIT/HardwareIntrinsics/General/Vector128_1/GetAndWithElement.Int64.0.cs
+++ b/tests/src/JIT/HardwareIntrinsics/General/Vector128_1/GetAndWithElement.Int64.0.cs
@@ -74,10 +74,10 @@ public void RunBasicScenario(int imm = 0, bool expectedOutOfRangeException = fal
 
             if (!succeeded)
             {
-                Succeeded = false;
-
                 TestLibrary.TestFramework.LogInformation($"Vector128<Int64.GetElement({imm}): {nameof(RunBasicScenario)} failed to throw ArgumentOutOfRangeException.");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
 
             succeeded = !expectedOutOfRangeException;
@@ -96,10 +96,10 @@ public void RunBasicScenario(int imm = 0, bool expectedOutOfRangeException = fal
 
             if (!succeeded)
             {
-                Succeeded = false;
-
                 TestLibrary.TestFramework.LogInformation($"Vector128<Int64.WithElement({imm}): {nameof(RunBasicScenario)} failed to throw ArgumentOutOfRangeException.");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
 
@@ -133,10 +133,10 @@ public void RunReflectionScenario(int imm = 0, bool expectedOutOfRangeException
 
             if (!succeeded)
             {
-                Succeeded = false;
-
                 TestLibrary.TestFramework.LogInformation($"Vector128<Int64.GetElement({imm}): {nameof(RunReflectionScenario)} failed to throw ArgumentOutOfRangeException.");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
 
             succeeded = !expectedOutOfRangeException;
@@ -158,10 +158,10 @@ public void RunReflectionScenario(int imm = 0, bool expectedOutOfRangeException
 
             if (!succeeded)
             {
-                Succeeded = false;
-
                 TestLibrary.TestFramework.LogInformation($"Vector128<Int64.WithElement({imm}): {nameof(RunReflectionScenario)} failed to throw ArgumentOutOfRangeException.");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
 
@@ -196,27 +196,31 @@ private void ValidateWithResult(Vector128<Int64> result, Int64[] values, Int64 i
 
         private void ValidateWithResult(Int64[] result, Int64[] values, Int64 insertedValue, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             for (int i = 0; i < ElementCount; i++)
             {
                 if ((i != 0) && (result[i] != values[i]))
                 {
-                    Succeeded = false;
+                    succeeded = false;
                     break;
                 }
             }
 
             if (result[0] != insertedValue)
             {
-                Succeeded = false;
+                succeeded = false;
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"Vector128<Int64.WithElement(0): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"   value: ({string.Join(", ", values)})");
                 TestLibrary.TestFramework.LogInformation($"  insert: insertedValue");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/General/Vector128_1/GetAndWithElement.Int64.1.cs b/tests/src/JIT/HardwareIntrinsics/General/Vector128_1/GetAndWithElement.Int64.1.cs
index 06bb07d00b78..6e3315bcf7a0 100644
--- a/tests/src/JIT/HardwareIntrinsics/General/Vector128_1/GetAndWithElement.Int64.1.cs
+++ b/tests/src/JIT/HardwareIntrinsics/General/Vector128_1/GetAndWithElement.Int64.1.cs
@@ -74,10 +74,10 @@ public void RunBasicScenario(int imm = 1, bool expectedOutOfRangeException = fal
 
             if (!succeeded)
             {
-                Succeeded = false;
-
                 TestLibrary.TestFramework.LogInformation($"Vector128<Int64.GetElement({imm}): {nameof(RunBasicScenario)} failed to throw ArgumentOutOfRangeException.");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
 
             succeeded = !expectedOutOfRangeException;
@@ -96,10 +96,10 @@ public void RunBasicScenario(int imm = 1, bool expectedOutOfRangeException = fal
 
             if (!succeeded)
             {
-                Succeeded = false;
-
                 TestLibrary.TestFramework.LogInformation($"Vector128<Int64.WithElement({imm}): {nameof(RunBasicScenario)} failed to throw ArgumentOutOfRangeException.");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
 
@@ -133,10 +133,10 @@ public void RunReflectionScenario(int imm = 1, bool expectedOutOfRangeException
 
             if (!succeeded)
             {
-                Succeeded = false;
-
                 TestLibrary.TestFramework.LogInformation($"Vector128<Int64.GetElement({imm}): {nameof(RunReflectionScenario)} failed to throw ArgumentOutOfRangeException.");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
 
             succeeded = !expectedOutOfRangeException;
@@ -158,10 +158,10 @@ public void RunReflectionScenario(int imm = 1, bool expectedOutOfRangeException
 
             if (!succeeded)
             {
-                Succeeded = false;
-
                 TestLibrary.TestFramework.LogInformation($"Vector128<Int64.WithElement({imm}): {nameof(RunReflectionScenario)} failed to throw ArgumentOutOfRangeException.");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
 
@@ -196,27 +196,31 @@ private void ValidateWithResult(Vector128<Int64> result, Int64[] values, Int64 i
 
         private void ValidateWithResult(Int64[] result, Int64[] values, Int64 insertedValue, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             for (int i = 0; i < ElementCount; i++)
             {
                 if ((i != 1) && (result[i] != values[i]))
                 {
-                    Succeeded = false;
+                    succeeded = false;
                     break;
                 }
             }
 
             if (result[1] != insertedValue)
             {
-                Succeeded = false;
+                succeeded = false;
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"Vector128<Int64.WithElement(1): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"   value: ({string.Join(", ", values)})");
                 TestLibrary.TestFramework.LogInformation($"  insert: insertedValue");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/General/Vector128_1/GetAndWithElement.SByte.0.cs b/tests/src/JIT/HardwareIntrinsics/General/Vector128_1/GetAndWithElement.SByte.0.cs
index c4e43ea878b3..a4bf1ca5f4be 100644
--- a/tests/src/JIT/HardwareIntrinsics/General/Vector128_1/GetAndWithElement.SByte.0.cs
+++ b/tests/src/JIT/HardwareIntrinsics/General/Vector128_1/GetAndWithElement.SByte.0.cs
@@ -74,10 +74,10 @@ public void RunBasicScenario(int imm = 0, bool expectedOutOfRangeException = fal
 
             if (!succeeded)
             {
-                Succeeded = false;
-
                 TestLibrary.TestFramework.LogInformation($"Vector128<SByte.GetElement({imm}): {nameof(RunBasicScenario)} failed to throw ArgumentOutOfRangeException.");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
 
             succeeded = !expectedOutOfRangeException;
@@ -96,10 +96,10 @@ public void RunBasicScenario(int imm = 0, bool expectedOutOfRangeException = fal
 
             if (!succeeded)
             {
-                Succeeded = false;
-
                 TestLibrary.TestFramework.LogInformation($"Vector128<SByte.WithElement({imm}): {nameof(RunBasicScenario)} failed to throw ArgumentOutOfRangeException.");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
 
@@ -133,10 +133,10 @@ public void RunReflectionScenario(int imm = 0, bool expectedOutOfRangeException
 
             if (!succeeded)
             {
-                Succeeded = false;
-
                 TestLibrary.TestFramework.LogInformation($"Vector128<SByte.GetElement({imm}): {nameof(RunReflectionScenario)} failed to throw ArgumentOutOfRangeException.");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
 
             succeeded = !expectedOutOfRangeException;
@@ -158,10 +158,10 @@ public void RunReflectionScenario(int imm = 0, bool expectedOutOfRangeException
 
             if (!succeeded)
             {
-                Succeeded = false;
-
                 TestLibrary.TestFramework.LogInformation($"Vector128<SByte.WithElement({imm}): {nameof(RunReflectionScenario)} failed to throw ArgumentOutOfRangeException.");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
 
@@ -196,27 +196,31 @@ private void ValidateWithResult(Vector128<SByte> result, SByte[] values, SByte i
 
         private void ValidateWithResult(SByte[] result, SByte[] values, SByte insertedValue, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             for (int i = 0; i < ElementCount; i++)
             {
                 if ((i != 0) && (result[i] != values[i]))
                 {
-                    Succeeded = false;
+                    succeeded = false;
                     break;
                 }
             }
 
             if (result[0] != insertedValue)
             {
-                Succeeded = false;
+                succeeded = false;
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"Vector128<SByte.WithElement(0): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"   value: ({string.Join(", ", values)})");
                 TestLibrary.TestFramework.LogInformation($"  insert: insertedValue");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/General/Vector128_1/GetAndWithElement.SByte.15.cs b/tests/src/JIT/HardwareIntrinsics/General/Vector128_1/GetAndWithElement.SByte.15.cs
index 6115654f985f..3abfdfb7c0ac 100644
--- a/tests/src/JIT/HardwareIntrinsics/General/Vector128_1/GetAndWithElement.SByte.15.cs
+++ b/tests/src/JIT/HardwareIntrinsics/General/Vector128_1/GetAndWithElement.SByte.15.cs
@@ -74,10 +74,10 @@ public void RunBasicScenario(int imm = 15, bool expectedOutOfRangeException = fa
 
             if (!succeeded)
             {
-                Succeeded = false;
-
                 TestLibrary.TestFramework.LogInformation($"Vector128<SByte.GetElement({imm}): {nameof(RunBasicScenario)} failed to throw ArgumentOutOfRangeException.");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
 
             succeeded = !expectedOutOfRangeException;
@@ -96,10 +96,10 @@ public void RunBasicScenario(int imm = 15, bool expectedOutOfRangeException = fa
 
             if (!succeeded)
             {
-                Succeeded = false;
-
                 TestLibrary.TestFramework.LogInformation($"Vector128<SByte.WithElement({imm}): {nameof(RunBasicScenario)} failed to throw ArgumentOutOfRangeException.");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
 
@@ -133,10 +133,10 @@ public void RunReflectionScenario(int imm = 15, bool expectedOutOfRangeException
 
             if (!succeeded)
             {
-                Succeeded = false;
-
                 TestLibrary.TestFramework.LogInformation($"Vector128<SByte.GetElement({imm}): {nameof(RunReflectionScenario)} failed to throw ArgumentOutOfRangeException.");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
 
             succeeded = !expectedOutOfRangeException;
@@ -158,10 +158,10 @@ public void RunReflectionScenario(int imm = 15, bool expectedOutOfRangeException
 
             if (!succeeded)
             {
-                Succeeded = false;
-
                 TestLibrary.TestFramework.LogInformation($"Vector128<SByte.WithElement({imm}): {nameof(RunReflectionScenario)} failed to throw ArgumentOutOfRangeException.");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
 
@@ -196,27 +196,31 @@ private void ValidateWithResult(Vector128<SByte> result, SByte[] values, SByte i
 
         private void ValidateWithResult(SByte[] result, SByte[] values, SByte insertedValue, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             for (int i = 0; i < ElementCount; i++)
             {
                 if ((i != 15) && (result[i] != values[i]))
                 {
-                    Succeeded = false;
+                    succeeded = false;
                     break;
                 }
             }
 
             if (result[15] != insertedValue)
             {
-                Succeeded = false;
+                succeeded = false;
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"Vector128<SByte.WithElement(15): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"   value: ({string.Join(", ", values)})");
                 TestLibrary.TestFramework.LogInformation($"  insert: insertedValue");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/General/Vector128_1/GetAndWithElement.SByte.7.cs b/tests/src/JIT/HardwareIntrinsics/General/Vector128_1/GetAndWithElement.SByte.7.cs
index 50a34c9b2aaf..2df7396c7cf7 100644
--- a/tests/src/JIT/HardwareIntrinsics/General/Vector128_1/GetAndWithElement.SByte.7.cs
+++ b/tests/src/JIT/HardwareIntrinsics/General/Vector128_1/GetAndWithElement.SByte.7.cs
@@ -74,10 +74,10 @@ public void RunBasicScenario(int imm = 7, bool expectedOutOfRangeException = fal
 
             if (!succeeded)
             {
-                Succeeded = false;
-
                 TestLibrary.TestFramework.LogInformation($"Vector128<SByte.GetElement({imm}): {nameof(RunBasicScenario)} failed to throw ArgumentOutOfRangeException.");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
 
             succeeded = !expectedOutOfRangeException;
@@ -96,10 +96,10 @@ public void RunBasicScenario(int imm = 7, bool expectedOutOfRangeException = fal
 
             if (!succeeded)
             {
-                Succeeded = false;
-
                 TestLibrary.TestFramework.LogInformation($"Vector128<SByte.WithElement({imm}): {nameof(RunBasicScenario)} failed to throw ArgumentOutOfRangeException.");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
 
@@ -133,10 +133,10 @@ public void RunReflectionScenario(int imm = 7, bool expectedOutOfRangeException
 
             if (!succeeded)
             {
-                Succeeded = false;
-
                 TestLibrary.TestFramework.LogInformation($"Vector128<SByte.GetElement({imm}): {nameof(RunReflectionScenario)} failed to throw ArgumentOutOfRangeException.");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
 
             succeeded = !expectedOutOfRangeException;
@@ -158,10 +158,10 @@ public void RunReflectionScenario(int imm = 7, bool expectedOutOfRangeException
 
             if (!succeeded)
             {
-                Succeeded = false;
-
                 TestLibrary.TestFramework.LogInformation($"Vector128<SByte.WithElement({imm}): {nameof(RunReflectionScenario)} failed to throw ArgumentOutOfRangeException.");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
 
@@ -196,27 +196,31 @@ private void ValidateWithResult(Vector128<SByte> result, SByte[] values, SByte i
 
         private void ValidateWithResult(SByte[] result, SByte[] values, SByte insertedValue, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             for (int i = 0; i < ElementCount; i++)
             {
                 if ((i != 7) && (result[i] != values[i]))
                 {
-                    Succeeded = false;
+                    succeeded = false;
                     break;
                 }
             }
 
             if (result[7] != insertedValue)
             {
-                Succeeded = false;
+                succeeded = false;
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"Vector128<SByte.WithElement(7): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"   value: ({string.Join(", ", values)})");
                 TestLibrary.TestFramework.LogInformation($"  insert: insertedValue");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/General/Vector128_1/GetAndWithElement.Single.0.cs b/tests/src/JIT/HardwareIntrinsics/General/Vector128_1/GetAndWithElement.Single.0.cs
index 42d23565eb45..a0a5ad035d79 100644
--- a/tests/src/JIT/HardwareIntrinsics/General/Vector128_1/GetAndWithElement.Single.0.cs
+++ b/tests/src/JIT/HardwareIntrinsics/General/Vector128_1/GetAndWithElement.Single.0.cs
@@ -74,10 +74,10 @@ public void RunBasicScenario(int imm = 0, bool expectedOutOfRangeException = fal
 
             if (!succeeded)
             {
-                Succeeded = false;
-
                 TestLibrary.TestFramework.LogInformation($"Vector128<Single.GetElement({imm}): {nameof(RunBasicScenario)} failed to throw ArgumentOutOfRangeException.");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
 
             succeeded = !expectedOutOfRangeException;
@@ -96,10 +96,10 @@ public void RunBasicScenario(int imm = 0, bool expectedOutOfRangeException = fal
 
             if (!succeeded)
             {
-                Succeeded = false;
-
                 TestLibrary.TestFramework.LogInformation($"Vector128<Single.WithElement({imm}): {nameof(RunBasicScenario)} failed to throw ArgumentOutOfRangeException.");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
 
@@ -133,10 +133,10 @@ public void RunReflectionScenario(int imm = 0, bool expectedOutOfRangeException
 
             if (!succeeded)
             {
-                Succeeded = false;
-
                 TestLibrary.TestFramework.LogInformation($"Vector128<Single.GetElement({imm}): {nameof(RunReflectionScenario)} failed to throw ArgumentOutOfRangeException.");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
 
             succeeded = !expectedOutOfRangeException;
@@ -158,10 +158,10 @@ public void RunReflectionScenario(int imm = 0, bool expectedOutOfRangeException
 
             if (!succeeded)
             {
-                Succeeded = false;
-
                 TestLibrary.TestFramework.LogInformation($"Vector128<Single.WithElement({imm}): {nameof(RunReflectionScenario)} failed to throw ArgumentOutOfRangeException.");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
 
@@ -196,27 +196,31 @@ private void ValidateWithResult(Vector128<Single> result, Single[] values, Singl
 
         private void ValidateWithResult(Single[] result, Single[] values, Single insertedValue, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             for (int i = 0; i < ElementCount; i++)
             {
                 if ((i != 0) && (result[i] != values[i]))
                 {
-                    Succeeded = false;
+                    succeeded = false;
                     break;
                 }
             }
 
             if (result[0] != insertedValue)
             {
-                Succeeded = false;
+                succeeded = false;
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"Vector128<Single.WithElement(0): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"   value: ({string.Join(", ", values)})");
                 TestLibrary.TestFramework.LogInformation($"  insert: insertedValue");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/General/Vector128_1/GetAndWithElement.Single.1.cs b/tests/src/JIT/HardwareIntrinsics/General/Vector128_1/GetAndWithElement.Single.1.cs
index ec5a69033bb9..9f0b007ea859 100644
--- a/tests/src/JIT/HardwareIntrinsics/General/Vector128_1/GetAndWithElement.Single.1.cs
+++ b/tests/src/JIT/HardwareIntrinsics/General/Vector128_1/GetAndWithElement.Single.1.cs
@@ -74,10 +74,10 @@ public void RunBasicScenario(int imm = 1, bool expectedOutOfRangeException = fal
 
             if (!succeeded)
             {
-                Succeeded = false;
-
                 TestLibrary.TestFramework.LogInformation($"Vector128<Single.GetElement({imm}): {nameof(RunBasicScenario)} failed to throw ArgumentOutOfRangeException.");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
 
             succeeded = !expectedOutOfRangeException;
@@ -96,10 +96,10 @@ public void RunBasicScenario(int imm = 1, bool expectedOutOfRangeException = fal
 
             if (!succeeded)
             {
-                Succeeded = false;
-
                 TestLibrary.TestFramework.LogInformation($"Vector128<Single.WithElement({imm}): {nameof(RunBasicScenario)} failed to throw ArgumentOutOfRangeException.");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
 
@@ -133,10 +133,10 @@ public void RunReflectionScenario(int imm = 1, bool expectedOutOfRangeException
 
             if (!succeeded)
             {
-                Succeeded = false;
-
                 TestLibrary.TestFramework.LogInformation($"Vector128<Single.GetElement({imm}): {nameof(RunReflectionScenario)} failed to throw ArgumentOutOfRangeException.");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
 
             succeeded = !expectedOutOfRangeException;
@@ -158,10 +158,10 @@ public void RunReflectionScenario(int imm = 1, bool expectedOutOfRangeException
 
             if (!succeeded)
             {
-                Succeeded = false;
-
                 TestLibrary.TestFramework.LogInformation($"Vector128<Single.WithElement({imm}): {nameof(RunReflectionScenario)} failed to throw ArgumentOutOfRangeException.");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
 
@@ -196,27 +196,31 @@ private void ValidateWithResult(Vector128<Single> result, Single[] values, Singl
 
         private void ValidateWithResult(Single[] result, Single[] values, Single insertedValue, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             for (int i = 0; i < ElementCount; i++)
             {
                 if ((i != 1) && (result[i] != values[i]))
                 {
-                    Succeeded = false;
+                    succeeded = false;
                     break;
                 }
             }
 
             if (result[1] != insertedValue)
             {
-                Succeeded = false;
+                succeeded = false;
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"Vector128<Single.WithElement(1): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"   value: ({string.Join(", ", values)})");
                 TestLibrary.TestFramework.LogInformation($"  insert: insertedValue");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/General/Vector128_1/GetAndWithElement.Single.3.cs b/tests/src/JIT/HardwareIntrinsics/General/Vector128_1/GetAndWithElement.Single.3.cs
index 422fb6a9ae7c..87952556942f 100644
--- a/tests/src/JIT/HardwareIntrinsics/General/Vector128_1/GetAndWithElement.Single.3.cs
+++ b/tests/src/JIT/HardwareIntrinsics/General/Vector128_1/GetAndWithElement.Single.3.cs
@@ -74,10 +74,10 @@ public void RunBasicScenario(int imm = 3, bool expectedOutOfRangeException = fal
 
             if (!succeeded)
             {
-                Succeeded = false;
-
                 TestLibrary.TestFramework.LogInformation($"Vector128<Single.GetElement({imm}): {nameof(RunBasicScenario)} failed to throw ArgumentOutOfRangeException.");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
 
             succeeded = !expectedOutOfRangeException;
@@ -96,10 +96,10 @@ public void RunBasicScenario(int imm = 3, bool expectedOutOfRangeException = fal
 
             if (!succeeded)
             {
-                Succeeded = false;
-
                 TestLibrary.TestFramework.LogInformation($"Vector128<Single.WithElement({imm}): {nameof(RunBasicScenario)} failed to throw ArgumentOutOfRangeException.");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
 
@@ -133,10 +133,10 @@ public void RunReflectionScenario(int imm = 3, bool expectedOutOfRangeException
 
             if (!succeeded)
             {
-                Succeeded = false;
-
                 TestLibrary.TestFramework.LogInformation($"Vector128<Single.GetElement({imm}): {nameof(RunReflectionScenario)} failed to throw ArgumentOutOfRangeException.");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
 
             succeeded = !expectedOutOfRangeException;
@@ -158,10 +158,10 @@ public void RunReflectionScenario(int imm = 3, bool expectedOutOfRangeException
 
             if (!succeeded)
             {
-                Succeeded = false;
-
                 TestLibrary.TestFramework.LogInformation($"Vector128<Single.WithElement({imm}): {nameof(RunReflectionScenario)} failed to throw ArgumentOutOfRangeException.");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
 
@@ -196,27 +196,31 @@ private void ValidateWithResult(Vector128<Single> result, Single[] values, Singl
 
         private void ValidateWithResult(Single[] result, Single[] values, Single insertedValue, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             for (int i = 0; i < ElementCount; i++)
             {
                 if ((i != 3) && (result[i] != values[i]))
                 {
-                    Succeeded = false;
+                    succeeded = false;
                     break;
                 }
             }
 
             if (result[3] != insertedValue)
             {
-                Succeeded = false;
+                succeeded = false;
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"Vector128<Single.WithElement(3): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"   value: ({string.Join(", ", values)})");
                 TestLibrary.TestFramework.LogInformation($"  insert: insertedValue");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/General/Vector128_1/GetAndWithElement.UInt16.0.cs b/tests/src/JIT/HardwareIntrinsics/General/Vector128_1/GetAndWithElement.UInt16.0.cs
index 2fa004279036..6d7b621d91b4 100644
--- a/tests/src/JIT/HardwareIntrinsics/General/Vector128_1/GetAndWithElement.UInt16.0.cs
+++ b/tests/src/JIT/HardwareIntrinsics/General/Vector128_1/GetAndWithElement.UInt16.0.cs
@@ -74,10 +74,10 @@ public void RunBasicScenario(int imm = 0, bool expectedOutOfRangeException = fal
 
             if (!succeeded)
             {
-                Succeeded = false;
-
                 TestLibrary.TestFramework.LogInformation($"Vector128<UInt16.GetElement({imm}): {nameof(RunBasicScenario)} failed to throw ArgumentOutOfRangeException.");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
 
             succeeded = !expectedOutOfRangeException;
@@ -96,10 +96,10 @@ public void RunBasicScenario(int imm = 0, bool expectedOutOfRangeException = fal
 
             if (!succeeded)
             {
-                Succeeded = false;
-
                 TestLibrary.TestFramework.LogInformation($"Vector128<UInt16.WithElement({imm}): {nameof(RunBasicScenario)} failed to throw ArgumentOutOfRangeException.");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
 
@@ -133,10 +133,10 @@ public void RunReflectionScenario(int imm = 0, bool expectedOutOfRangeException
 
             if (!succeeded)
             {
-                Succeeded = false;
-
                 TestLibrary.TestFramework.LogInformation($"Vector128<UInt16.GetElement({imm}): {nameof(RunReflectionScenario)} failed to throw ArgumentOutOfRangeException.");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
 
             succeeded = !expectedOutOfRangeException;
@@ -158,10 +158,10 @@ public void RunReflectionScenario(int imm = 0, bool expectedOutOfRangeException
 
             if (!succeeded)
             {
-                Succeeded = false;
-
                 TestLibrary.TestFramework.LogInformation($"Vector128<UInt16.WithElement({imm}): {nameof(RunReflectionScenario)} failed to throw ArgumentOutOfRangeException.");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
 
@@ -196,27 +196,31 @@ private void ValidateWithResult(Vector128<UInt16> result, UInt16[] values, UInt1
 
         private void ValidateWithResult(UInt16[] result, UInt16[] values, UInt16 insertedValue, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             for (int i = 0; i < ElementCount; i++)
             {
                 if ((i != 0) && (result[i] != values[i]))
                 {
-                    Succeeded = false;
+                    succeeded = false;
                     break;
                 }
             }
 
             if (result[0] != insertedValue)
             {
-                Succeeded = false;
+                succeeded = false;
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"Vector128<UInt16.WithElement(0): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"   value: ({string.Join(", ", values)})");
                 TestLibrary.TestFramework.LogInformation($"  insert: insertedValue");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/General/Vector128_1/GetAndWithElement.UInt16.3.cs b/tests/src/JIT/HardwareIntrinsics/General/Vector128_1/GetAndWithElement.UInt16.3.cs
index 5e11f6ed32a9..0c3a2bfa54fb 100644
--- a/tests/src/JIT/HardwareIntrinsics/General/Vector128_1/GetAndWithElement.UInt16.3.cs
+++ b/tests/src/JIT/HardwareIntrinsics/General/Vector128_1/GetAndWithElement.UInt16.3.cs
@@ -74,10 +74,10 @@ public void RunBasicScenario(int imm = 3, bool expectedOutOfRangeException = fal
 
             if (!succeeded)
             {
-                Succeeded = false;
-
                 TestLibrary.TestFramework.LogInformation($"Vector128<UInt16.GetElement({imm}): {nameof(RunBasicScenario)} failed to throw ArgumentOutOfRangeException.");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
 
             succeeded = !expectedOutOfRangeException;
@@ -96,10 +96,10 @@ public void RunBasicScenario(int imm = 3, bool expectedOutOfRangeException = fal
 
             if (!succeeded)
             {
-                Succeeded = false;
-
                 TestLibrary.TestFramework.LogInformation($"Vector128<UInt16.WithElement({imm}): {nameof(RunBasicScenario)} failed to throw ArgumentOutOfRangeException.");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
 
@@ -133,10 +133,10 @@ public void RunReflectionScenario(int imm = 3, bool expectedOutOfRangeException
 
             if (!succeeded)
             {
-                Succeeded = false;
-
                 TestLibrary.TestFramework.LogInformation($"Vector128<UInt16.GetElement({imm}): {nameof(RunReflectionScenario)} failed to throw ArgumentOutOfRangeException.");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
 
             succeeded = !expectedOutOfRangeException;
@@ -158,10 +158,10 @@ public void RunReflectionScenario(int imm = 3, bool expectedOutOfRangeException
 
             if (!succeeded)
             {
-                Succeeded = false;
-
                 TestLibrary.TestFramework.LogInformation($"Vector128<UInt16.WithElement({imm}): {nameof(RunReflectionScenario)} failed to throw ArgumentOutOfRangeException.");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
 
@@ -196,27 +196,31 @@ private void ValidateWithResult(Vector128<UInt16> result, UInt16[] values, UInt1
 
         private void ValidateWithResult(UInt16[] result, UInt16[] values, UInt16 insertedValue, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             for (int i = 0; i < ElementCount; i++)
             {
                 if ((i != 3) && (result[i] != values[i]))
                 {
-                    Succeeded = false;
+                    succeeded = false;
                     break;
                 }
             }
 
             if (result[3] != insertedValue)
             {
-                Succeeded = false;
+                succeeded = false;
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"Vector128<UInt16.WithElement(3): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"   value: ({string.Join(", ", values)})");
                 TestLibrary.TestFramework.LogInformation($"  insert: insertedValue");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/General/Vector128_1/GetAndWithElement.UInt16.7.cs b/tests/src/JIT/HardwareIntrinsics/General/Vector128_1/GetAndWithElement.UInt16.7.cs
index 5d956fae966e..ced4f105924f 100644
--- a/tests/src/JIT/HardwareIntrinsics/General/Vector128_1/GetAndWithElement.UInt16.7.cs
+++ b/tests/src/JIT/HardwareIntrinsics/General/Vector128_1/GetAndWithElement.UInt16.7.cs
@@ -74,10 +74,10 @@ public void RunBasicScenario(int imm = 7, bool expectedOutOfRangeException = fal
 
             if (!succeeded)
             {
-                Succeeded = false;
-
                 TestLibrary.TestFramework.LogInformation($"Vector128<UInt16.GetElement({imm}): {nameof(RunBasicScenario)} failed to throw ArgumentOutOfRangeException.");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
 
             succeeded = !expectedOutOfRangeException;
@@ -96,10 +96,10 @@ public void RunBasicScenario(int imm = 7, bool expectedOutOfRangeException = fal
 
             if (!succeeded)
             {
-                Succeeded = false;
-
                 TestLibrary.TestFramework.LogInformation($"Vector128<UInt16.WithElement({imm}): {nameof(RunBasicScenario)} failed to throw ArgumentOutOfRangeException.");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
 
@@ -133,10 +133,10 @@ public void RunReflectionScenario(int imm = 7, bool expectedOutOfRangeException
 
             if (!succeeded)
             {
-                Succeeded = false;
-
                 TestLibrary.TestFramework.LogInformation($"Vector128<UInt16.GetElement({imm}): {nameof(RunReflectionScenario)} failed to throw ArgumentOutOfRangeException.");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
 
             succeeded = !expectedOutOfRangeException;
@@ -158,10 +158,10 @@ public void RunReflectionScenario(int imm = 7, bool expectedOutOfRangeException
 
             if (!succeeded)
             {
-                Succeeded = false;
-
                 TestLibrary.TestFramework.LogInformation($"Vector128<UInt16.WithElement({imm}): {nameof(RunReflectionScenario)} failed to throw ArgumentOutOfRangeException.");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
 
@@ -196,27 +196,31 @@ private void ValidateWithResult(Vector128<UInt16> result, UInt16[] values, UInt1
 
         private void ValidateWithResult(UInt16[] result, UInt16[] values, UInt16 insertedValue, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             for (int i = 0; i < ElementCount; i++)
             {
                 if ((i != 7) && (result[i] != values[i]))
                 {
-                    Succeeded = false;
+                    succeeded = false;
                     break;
                 }
             }
 
             if (result[7] != insertedValue)
             {
-                Succeeded = false;
+                succeeded = false;
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"Vector128<UInt16.WithElement(7): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"   value: ({string.Join(", ", values)})");
                 TestLibrary.TestFramework.LogInformation($"  insert: insertedValue");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/General/Vector128_1/GetAndWithElement.UInt32.0.cs b/tests/src/JIT/HardwareIntrinsics/General/Vector128_1/GetAndWithElement.UInt32.0.cs
index 636ece15d270..b807c9cf12f6 100644
--- a/tests/src/JIT/HardwareIntrinsics/General/Vector128_1/GetAndWithElement.UInt32.0.cs
+++ b/tests/src/JIT/HardwareIntrinsics/General/Vector128_1/GetAndWithElement.UInt32.0.cs
@@ -74,10 +74,10 @@ public void RunBasicScenario(int imm = 0, bool expectedOutOfRangeException = fal
 
             if (!succeeded)
             {
-                Succeeded = false;
-
                 TestLibrary.TestFramework.LogInformation($"Vector128<UInt32.GetElement({imm}): {nameof(RunBasicScenario)} failed to throw ArgumentOutOfRangeException.");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
 
             succeeded = !expectedOutOfRangeException;
@@ -96,10 +96,10 @@ public void RunBasicScenario(int imm = 0, bool expectedOutOfRangeException = fal
 
             if (!succeeded)
             {
-                Succeeded = false;
-
                 TestLibrary.TestFramework.LogInformation($"Vector128<UInt32.WithElement({imm}): {nameof(RunBasicScenario)} failed to throw ArgumentOutOfRangeException.");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
 
@@ -133,10 +133,10 @@ public void RunReflectionScenario(int imm = 0, bool expectedOutOfRangeException
 
             if (!succeeded)
             {
-                Succeeded = false;
-
                 TestLibrary.TestFramework.LogInformation($"Vector128<UInt32.GetElement({imm}): {nameof(RunReflectionScenario)} failed to throw ArgumentOutOfRangeException.");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
 
             succeeded = !expectedOutOfRangeException;
@@ -158,10 +158,10 @@ public void RunReflectionScenario(int imm = 0, bool expectedOutOfRangeException
 
             if (!succeeded)
             {
-                Succeeded = false;
-
                 TestLibrary.TestFramework.LogInformation($"Vector128<UInt32.WithElement({imm}): {nameof(RunReflectionScenario)} failed to throw ArgumentOutOfRangeException.");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
 
@@ -196,27 +196,31 @@ private void ValidateWithResult(Vector128<UInt32> result, UInt32[] values, UInt3
 
         private void ValidateWithResult(UInt32[] result, UInt32[] values, UInt32 insertedValue, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             for (int i = 0; i < ElementCount; i++)
             {
                 if ((i != 0) && (result[i] != values[i]))
                 {
-                    Succeeded = false;
+                    succeeded = false;
                     break;
                 }
             }
 
             if (result[0] != insertedValue)
             {
-                Succeeded = false;
+                succeeded = false;
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"Vector128<UInt32.WithElement(0): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"   value: ({string.Join(", ", values)})");
                 TestLibrary.TestFramework.LogInformation($"  insert: insertedValue");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/General/Vector128_1/GetAndWithElement.UInt32.1.cs b/tests/src/JIT/HardwareIntrinsics/General/Vector128_1/GetAndWithElement.UInt32.1.cs
index 918ee3d01e93..25fa59ae2c8d 100644
--- a/tests/src/JIT/HardwareIntrinsics/General/Vector128_1/GetAndWithElement.UInt32.1.cs
+++ b/tests/src/JIT/HardwareIntrinsics/General/Vector128_1/GetAndWithElement.UInt32.1.cs
@@ -74,10 +74,10 @@ public void RunBasicScenario(int imm = 1, bool expectedOutOfRangeException = fal
 
             if (!succeeded)
             {
-                Succeeded = false;
-
                 TestLibrary.TestFramework.LogInformation($"Vector128<UInt32.GetElement({imm}): {nameof(RunBasicScenario)} failed to throw ArgumentOutOfRangeException.");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
 
             succeeded = !expectedOutOfRangeException;
@@ -96,10 +96,10 @@ public void RunBasicScenario(int imm = 1, bool expectedOutOfRangeException = fal
 
             if (!succeeded)
             {
-                Succeeded = false;
-
                 TestLibrary.TestFramework.LogInformation($"Vector128<UInt32.WithElement({imm}): {nameof(RunBasicScenario)} failed to throw ArgumentOutOfRangeException.");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
 
@@ -133,10 +133,10 @@ public void RunReflectionScenario(int imm = 1, bool expectedOutOfRangeException
 
             if (!succeeded)
             {
-                Succeeded = false;
-
                 TestLibrary.TestFramework.LogInformation($"Vector128<UInt32.GetElement({imm}): {nameof(RunReflectionScenario)} failed to throw ArgumentOutOfRangeException.");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
 
             succeeded = !expectedOutOfRangeException;
@@ -158,10 +158,10 @@ public void RunReflectionScenario(int imm = 1, bool expectedOutOfRangeException
 
             if (!succeeded)
             {
-                Succeeded = false;
-
                 TestLibrary.TestFramework.LogInformation($"Vector128<UInt32.WithElement({imm}): {nameof(RunReflectionScenario)} failed to throw ArgumentOutOfRangeException.");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
 
@@ -196,27 +196,31 @@ private void ValidateWithResult(Vector128<UInt32> result, UInt32[] values, UInt3
 
         private void ValidateWithResult(UInt32[] result, UInt32[] values, UInt32 insertedValue, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             for (int i = 0; i < ElementCount; i++)
             {
                 if ((i != 1) && (result[i] != values[i]))
                 {
-                    Succeeded = false;
+                    succeeded = false;
                     break;
                 }
             }
 
             if (result[1] != insertedValue)
             {
-                Succeeded = false;
+                succeeded = false;
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"Vector128<UInt32.WithElement(1): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"   value: ({string.Join(", ", values)})");
                 TestLibrary.TestFramework.LogInformation($"  insert: insertedValue");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/General/Vector128_1/GetAndWithElement.UInt32.3.cs b/tests/src/JIT/HardwareIntrinsics/General/Vector128_1/GetAndWithElement.UInt32.3.cs
index d399d450ff40..bfb385ea06ce 100644
--- a/tests/src/JIT/HardwareIntrinsics/General/Vector128_1/GetAndWithElement.UInt32.3.cs
+++ b/tests/src/JIT/HardwareIntrinsics/General/Vector128_1/GetAndWithElement.UInt32.3.cs
@@ -74,10 +74,10 @@ public void RunBasicScenario(int imm = 3, bool expectedOutOfRangeException = fal
 
             if (!succeeded)
             {
-                Succeeded = false;
-
                 TestLibrary.TestFramework.LogInformation($"Vector128<UInt32.GetElement({imm}): {nameof(RunBasicScenario)} failed to throw ArgumentOutOfRangeException.");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
 
             succeeded = !expectedOutOfRangeException;
@@ -96,10 +96,10 @@ public void RunBasicScenario(int imm = 3, bool expectedOutOfRangeException = fal
 
             if (!succeeded)
             {
-                Succeeded = false;
-
                 TestLibrary.TestFramework.LogInformation($"Vector128<UInt32.WithElement({imm}): {nameof(RunBasicScenario)} failed to throw ArgumentOutOfRangeException.");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
 
@@ -133,10 +133,10 @@ public void RunReflectionScenario(int imm = 3, bool expectedOutOfRangeException
 
             if (!succeeded)
             {
-                Succeeded = false;
-
                 TestLibrary.TestFramework.LogInformation($"Vector128<UInt32.GetElement({imm}): {nameof(RunReflectionScenario)} failed to throw ArgumentOutOfRangeException.");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
 
             succeeded = !expectedOutOfRangeException;
@@ -158,10 +158,10 @@ public void RunReflectionScenario(int imm = 3, bool expectedOutOfRangeException
 
             if (!succeeded)
             {
-                Succeeded = false;
-
                 TestLibrary.TestFramework.LogInformation($"Vector128<UInt32.WithElement({imm}): {nameof(RunReflectionScenario)} failed to throw ArgumentOutOfRangeException.");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
 
@@ -196,27 +196,31 @@ private void ValidateWithResult(Vector128<UInt32> result, UInt32[] values, UInt3
 
         private void ValidateWithResult(UInt32[] result, UInt32[] values, UInt32 insertedValue, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             for (int i = 0; i < ElementCount; i++)
             {
                 if ((i != 3) && (result[i] != values[i]))
                 {
-                    Succeeded = false;
+                    succeeded = false;
                     break;
                 }
             }
 
             if (result[3] != insertedValue)
             {
-                Succeeded = false;
+                succeeded = false;
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"Vector128<UInt32.WithElement(3): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"   value: ({string.Join(", ", values)})");
                 TestLibrary.TestFramework.LogInformation($"  insert: insertedValue");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/General/Vector128_1/GetAndWithElement.UInt64.0.cs b/tests/src/JIT/HardwareIntrinsics/General/Vector128_1/GetAndWithElement.UInt64.0.cs
index 3b547efd9d0a..ffe0d5c48c7e 100644
--- a/tests/src/JIT/HardwareIntrinsics/General/Vector128_1/GetAndWithElement.UInt64.0.cs
+++ b/tests/src/JIT/HardwareIntrinsics/General/Vector128_1/GetAndWithElement.UInt64.0.cs
@@ -74,10 +74,10 @@ public void RunBasicScenario(int imm = 0, bool expectedOutOfRangeException = fal
 
             if (!succeeded)
             {
-                Succeeded = false;
-
                 TestLibrary.TestFramework.LogInformation($"Vector128<UInt64.GetElement({imm}): {nameof(RunBasicScenario)} failed to throw ArgumentOutOfRangeException.");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
 
             succeeded = !expectedOutOfRangeException;
@@ -96,10 +96,10 @@ public void RunBasicScenario(int imm = 0, bool expectedOutOfRangeException = fal
 
             if (!succeeded)
             {
-                Succeeded = false;
-
                 TestLibrary.TestFramework.LogInformation($"Vector128<UInt64.WithElement({imm}): {nameof(RunBasicScenario)} failed to throw ArgumentOutOfRangeException.");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
 
@@ -133,10 +133,10 @@ public void RunReflectionScenario(int imm = 0, bool expectedOutOfRangeException
 
             if (!succeeded)
             {
-                Succeeded = false;
-
                 TestLibrary.TestFramework.LogInformation($"Vector128<UInt64.GetElement({imm}): {nameof(RunReflectionScenario)} failed to throw ArgumentOutOfRangeException.");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
 
             succeeded = !expectedOutOfRangeException;
@@ -158,10 +158,10 @@ public void RunReflectionScenario(int imm = 0, bool expectedOutOfRangeException
 
             if (!succeeded)
             {
-                Succeeded = false;
-
                 TestLibrary.TestFramework.LogInformation($"Vector128<UInt64.WithElement({imm}): {nameof(RunReflectionScenario)} failed to throw ArgumentOutOfRangeException.");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
 
@@ -196,27 +196,31 @@ private void ValidateWithResult(Vector128<UInt64> result, UInt64[] values, UInt6
 
         private void ValidateWithResult(UInt64[] result, UInt64[] values, UInt64 insertedValue, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             for (int i = 0; i < ElementCount; i++)
             {
                 if ((i != 0) && (result[i] != values[i]))
                 {
-                    Succeeded = false;
+                    succeeded = false;
                     break;
                 }
             }
 
             if (result[0] != insertedValue)
             {
-                Succeeded = false;
+                succeeded = false;
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"Vector128<UInt64.WithElement(0): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"   value: ({string.Join(", ", values)})");
                 TestLibrary.TestFramework.LogInformation($"  insert: insertedValue");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/General/Vector128_1/GetAndWithElement.UInt64.1.cs b/tests/src/JIT/HardwareIntrinsics/General/Vector128_1/GetAndWithElement.UInt64.1.cs
index 4dd57385c269..91c607ef6446 100644
--- a/tests/src/JIT/HardwareIntrinsics/General/Vector128_1/GetAndWithElement.UInt64.1.cs
+++ b/tests/src/JIT/HardwareIntrinsics/General/Vector128_1/GetAndWithElement.UInt64.1.cs
@@ -74,10 +74,10 @@ public void RunBasicScenario(int imm = 1, bool expectedOutOfRangeException = fal
 
             if (!succeeded)
             {
-                Succeeded = false;
-
                 TestLibrary.TestFramework.LogInformation($"Vector128<UInt64.GetElement({imm}): {nameof(RunBasicScenario)} failed to throw ArgumentOutOfRangeException.");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
 
             succeeded = !expectedOutOfRangeException;
@@ -96,10 +96,10 @@ public void RunBasicScenario(int imm = 1, bool expectedOutOfRangeException = fal
 
             if (!succeeded)
             {
-                Succeeded = false;
-
                 TestLibrary.TestFramework.LogInformation($"Vector128<UInt64.WithElement({imm}): {nameof(RunBasicScenario)} failed to throw ArgumentOutOfRangeException.");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
 
@@ -133,10 +133,10 @@ public void RunReflectionScenario(int imm = 1, bool expectedOutOfRangeException
 
             if (!succeeded)
             {
-                Succeeded = false;
-
                 TestLibrary.TestFramework.LogInformation($"Vector128<UInt64.GetElement({imm}): {nameof(RunReflectionScenario)} failed to throw ArgumentOutOfRangeException.");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
 
             succeeded = !expectedOutOfRangeException;
@@ -158,10 +158,10 @@ public void RunReflectionScenario(int imm = 1, bool expectedOutOfRangeException
 
             if (!succeeded)
             {
-                Succeeded = false;
-
                 TestLibrary.TestFramework.LogInformation($"Vector128<UInt64.WithElement({imm}): {nameof(RunReflectionScenario)} failed to throw ArgumentOutOfRangeException.");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
 
@@ -196,27 +196,31 @@ private void ValidateWithResult(Vector128<UInt64> result, UInt64[] values, UInt6
 
         private void ValidateWithResult(UInt64[] result, UInt64[] values, UInt64 insertedValue, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             for (int i = 0; i < ElementCount; i++)
             {
                 if ((i != 1) && (result[i] != values[i]))
                 {
-                    Succeeded = false;
+                    succeeded = false;
                     break;
                 }
             }
 
             if (result[1] != insertedValue)
             {
-                Succeeded = false;
+                succeeded = false;
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"Vector128<UInt64.WithElement(1): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"   value: ({string.Join(", ", values)})");
                 TestLibrary.TestFramework.LogInformation($"  insert: insertedValue");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/General/Vector128_1/GetAndWithLowerAndUpper.Byte.cs b/tests/src/JIT/HardwareIntrinsics/General/Vector128_1/GetAndWithLowerAndUpper.Byte.cs
index bb1a047899b3..b6038793015e 100644
--- a/tests/src/JIT/HardwareIntrinsics/General/Vector128_1/GetAndWithLowerAndUpper.Byte.cs
+++ b/tests/src/JIT/HardwareIntrinsics/General/Vector128_1/GetAndWithLowerAndUpper.Byte.cs
@@ -108,38 +108,46 @@ private void ValidateGetResult(Vector64<Byte> lowerResult, Vector64<Byte> upperR
 
         private void ValidateGetResult(Byte[] lowerResult, Byte[] upperResult, Byte[] values, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             for (int i = 0; i < ElementCount / 2; i++)
             {
                 if (lowerResult[i] != values[i])
                 {
-                    Succeeded = false;
+                    succeeded = false;
                     break;
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"Vector128<Byte>.GetLower(): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"   value: ({string.Join(", ", values)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", lowerResult)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
 
+            succeeded = true;
+
             for (int i = ElementCount / 2; i < ElementCount; i++)
             {
                 if (upperResult[i - (ElementCount / 2)] != values[i])
                 {
-                    Succeeded = false;
+                    succeeded = false;
                     break;
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"Vector128<Byte>.GetUpper(): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"   value: ({string.Join(", ", values)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", upperResult)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
 
@@ -152,38 +160,46 @@ private void ValidateWithResult(Vector128<Byte> result, Byte[] values, [CallerMe
 
         private void ValidateWithResult(Byte[] result, Byte[] values, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             for (int i = 0; i < ElementCount / 2; i++)
             {
                 if (result[i] != values[i + (ElementCount / 2)])
                 {
-                    Succeeded = false;
+                    succeeded = false;
                     break;
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"Vector128<Byte.WithLower(): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"   value: ({string.Join(", ", values)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
 
+            succeeded = true;
+
             for (int i = ElementCount / 2; i < ElementCount; i++)
             {
                 if (result[i] != values[i - (ElementCount / 2)])
                 {
-                    Succeeded = false;
+                    succeeded = false;
                     break;
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"Vector128<Byte.WithUpper(): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"   value: ({string.Join(", ", values)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/General/Vector128_1/GetAndWithLowerAndUpper.Double.cs b/tests/src/JIT/HardwareIntrinsics/General/Vector128_1/GetAndWithLowerAndUpper.Double.cs
index 8ee9eb69e310..5de952d740e1 100644
--- a/tests/src/JIT/HardwareIntrinsics/General/Vector128_1/GetAndWithLowerAndUpper.Double.cs
+++ b/tests/src/JIT/HardwareIntrinsics/General/Vector128_1/GetAndWithLowerAndUpper.Double.cs
@@ -108,38 +108,46 @@ private void ValidateGetResult(Vector64<Double> lowerResult, Vector64<Double> up
 
         private void ValidateGetResult(Double[] lowerResult, Double[] upperResult, Double[] values, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             for (int i = 0; i < ElementCount / 2; i++)
             {
                 if (lowerResult[i] != values[i])
                 {
-                    Succeeded = false;
+                    succeeded = false;
                     break;
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"Vector128<Double>.GetLower(): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"   value: ({string.Join(", ", values)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", lowerResult)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
 
+            succeeded = true;
+
             for (int i = ElementCount / 2; i < ElementCount; i++)
             {
                 if (upperResult[i - (ElementCount / 2)] != values[i])
                 {
-                    Succeeded = false;
+                    succeeded = false;
                     break;
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"Vector128<Double>.GetUpper(): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"   value: ({string.Join(", ", values)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", upperResult)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
 
@@ -152,38 +160,46 @@ private void ValidateWithResult(Vector128<Double> result, Double[] values, [Call
 
         private void ValidateWithResult(Double[] result, Double[] values, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             for (int i = 0; i < ElementCount / 2; i++)
             {
                 if (result[i] != values[i + (ElementCount / 2)])
                 {
-                    Succeeded = false;
+                    succeeded = false;
                     break;
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"Vector128<Double.WithLower(): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"   value: ({string.Join(", ", values)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
 
+            succeeded = true;
+
             for (int i = ElementCount / 2; i < ElementCount; i++)
             {
                 if (result[i] != values[i - (ElementCount / 2)])
                 {
-                    Succeeded = false;
+                    succeeded = false;
                     break;
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"Vector128<Double.WithUpper(): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"   value: ({string.Join(", ", values)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/General/Vector128_1/GetAndWithLowerAndUpper.Int16.cs b/tests/src/JIT/HardwareIntrinsics/General/Vector128_1/GetAndWithLowerAndUpper.Int16.cs
index 9bd2f70c1ee8..4ac435adb778 100644
--- a/tests/src/JIT/HardwareIntrinsics/General/Vector128_1/GetAndWithLowerAndUpper.Int16.cs
+++ b/tests/src/JIT/HardwareIntrinsics/General/Vector128_1/GetAndWithLowerAndUpper.Int16.cs
@@ -108,38 +108,46 @@ private void ValidateGetResult(Vector64<Int16> lowerResult, Vector64<Int16> uppe
 
         private void ValidateGetResult(Int16[] lowerResult, Int16[] upperResult, Int16[] values, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             for (int i = 0; i < ElementCount / 2; i++)
             {
                 if (lowerResult[i] != values[i])
                 {
-                    Succeeded = false;
+                    succeeded = false;
                     break;
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"Vector128<Int16>.GetLower(): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"   value: ({string.Join(", ", values)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", lowerResult)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
 
+            succeeded = true;
+
             for (int i = ElementCount / 2; i < ElementCount; i++)
             {
                 if (upperResult[i - (ElementCount / 2)] != values[i])
                 {
-                    Succeeded = false;
+                    succeeded = false;
                     break;
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"Vector128<Int16>.GetUpper(): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"   value: ({string.Join(", ", values)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", upperResult)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
 
@@ -152,38 +160,46 @@ private void ValidateWithResult(Vector128<Int16> result, Int16[] values, [Caller
 
         private void ValidateWithResult(Int16[] result, Int16[] values, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             for (int i = 0; i < ElementCount / 2; i++)
             {
                 if (result[i] != values[i + (ElementCount / 2)])
                 {
-                    Succeeded = false;
+                    succeeded = false;
                     break;
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"Vector128<Int16.WithLower(): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"   value: ({string.Join(", ", values)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
 
+            succeeded = true;
+
             for (int i = ElementCount / 2; i < ElementCount; i++)
             {
                 if (result[i] != values[i - (ElementCount / 2)])
                 {
-                    Succeeded = false;
+                    succeeded = false;
                     break;
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"Vector128<Int16.WithUpper(): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"   value: ({string.Join(", ", values)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/General/Vector128_1/GetAndWithLowerAndUpper.Int32.cs b/tests/src/JIT/HardwareIntrinsics/General/Vector128_1/GetAndWithLowerAndUpper.Int32.cs
index 7554b593a824..e785bbb140f3 100644
--- a/tests/src/JIT/HardwareIntrinsics/General/Vector128_1/GetAndWithLowerAndUpper.Int32.cs
+++ b/tests/src/JIT/HardwareIntrinsics/General/Vector128_1/GetAndWithLowerAndUpper.Int32.cs
@@ -108,38 +108,46 @@ private void ValidateGetResult(Vector64<Int32> lowerResult, Vector64<Int32> uppe
 
         private void ValidateGetResult(Int32[] lowerResult, Int32[] upperResult, Int32[] values, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             for (int i = 0; i < ElementCount / 2; i++)
             {
                 if (lowerResult[i] != values[i])
                 {
-                    Succeeded = false;
+                    succeeded = false;
                     break;
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"Vector128<Int32>.GetLower(): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"   value: ({string.Join(", ", values)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", lowerResult)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
 
+            succeeded = true;
+
             for (int i = ElementCount / 2; i < ElementCount; i++)
             {
                 if (upperResult[i - (ElementCount / 2)] != values[i])
                 {
-                    Succeeded = false;
+                    succeeded = false;
                     break;
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"Vector128<Int32>.GetUpper(): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"   value: ({string.Join(", ", values)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", upperResult)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
 
@@ -152,38 +160,46 @@ private void ValidateWithResult(Vector128<Int32> result, Int32[] values, [Caller
 
         private void ValidateWithResult(Int32[] result, Int32[] values, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             for (int i = 0; i < ElementCount / 2; i++)
             {
                 if (result[i] != values[i + (ElementCount / 2)])
                 {
-                    Succeeded = false;
+                    succeeded = false;
                     break;
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"Vector128<Int32.WithLower(): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"   value: ({string.Join(", ", values)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
 
+            succeeded = true;
+
             for (int i = ElementCount / 2; i < ElementCount; i++)
             {
                 if (result[i] != values[i - (ElementCount / 2)])
                 {
-                    Succeeded = false;
+                    succeeded = false;
                     break;
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"Vector128<Int32.WithUpper(): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"   value: ({string.Join(", ", values)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/General/Vector128_1/GetAndWithLowerAndUpper.Int64.cs b/tests/src/JIT/HardwareIntrinsics/General/Vector128_1/GetAndWithLowerAndUpper.Int64.cs
index 7230ffaeee32..71f70aeee3c5 100644
--- a/tests/src/JIT/HardwareIntrinsics/General/Vector128_1/GetAndWithLowerAndUpper.Int64.cs
+++ b/tests/src/JIT/HardwareIntrinsics/General/Vector128_1/GetAndWithLowerAndUpper.Int64.cs
@@ -108,38 +108,46 @@ private void ValidateGetResult(Vector64<Int64> lowerResult, Vector64<Int64> uppe
 
         private void ValidateGetResult(Int64[] lowerResult, Int64[] upperResult, Int64[] values, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             for (int i = 0; i < ElementCount / 2; i++)
             {
                 if (lowerResult[i] != values[i])
                 {
-                    Succeeded = false;
+                    succeeded = false;
                     break;
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"Vector128<Int64>.GetLower(): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"   value: ({string.Join(", ", values)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", lowerResult)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
 
+            succeeded = true;
+
             for (int i = ElementCount / 2; i < ElementCount; i++)
             {
                 if (upperResult[i - (ElementCount / 2)] != values[i])
                 {
-                    Succeeded = false;
+                    succeeded = false;
                     break;
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"Vector128<Int64>.GetUpper(): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"   value: ({string.Join(", ", values)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", upperResult)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
 
@@ -152,38 +160,46 @@ private void ValidateWithResult(Vector128<Int64> result, Int64[] values, [Caller
 
         private void ValidateWithResult(Int64[] result, Int64[] values, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             for (int i = 0; i < ElementCount / 2; i++)
             {
                 if (result[i] != values[i + (ElementCount / 2)])
                 {
-                    Succeeded = false;
+                    succeeded = false;
                     break;
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"Vector128<Int64.WithLower(): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"   value: ({string.Join(", ", values)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
 
+            succeeded = true;
+
             for (int i = ElementCount / 2; i < ElementCount; i++)
             {
                 if (result[i] != values[i - (ElementCount / 2)])
                 {
-                    Succeeded = false;
+                    succeeded = false;
                     break;
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"Vector128<Int64.WithUpper(): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"   value: ({string.Join(", ", values)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/General/Vector128_1/GetAndWithLowerAndUpper.SByte.cs b/tests/src/JIT/HardwareIntrinsics/General/Vector128_1/GetAndWithLowerAndUpper.SByte.cs
index 1d2740a391c5..8f23013ef304 100644
--- a/tests/src/JIT/HardwareIntrinsics/General/Vector128_1/GetAndWithLowerAndUpper.SByte.cs
+++ b/tests/src/JIT/HardwareIntrinsics/General/Vector128_1/GetAndWithLowerAndUpper.SByte.cs
@@ -108,38 +108,46 @@ private void ValidateGetResult(Vector64<SByte> lowerResult, Vector64<SByte> uppe
 
         private void ValidateGetResult(SByte[] lowerResult, SByte[] upperResult, SByte[] values, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             for (int i = 0; i < ElementCount / 2; i++)
             {
                 if (lowerResult[i] != values[i])
                 {
-                    Succeeded = false;
+                    succeeded = false;
                     break;
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"Vector128<SByte>.GetLower(): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"   value: ({string.Join(", ", values)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", lowerResult)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
 
+            succeeded = true;
+
             for (int i = ElementCount / 2; i < ElementCount; i++)
             {
                 if (upperResult[i - (ElementCount / 2)] != values[i])
                 {
-                    Succeeded = false;
+                    succeeded = false;
                     break;
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"Vector128<SByte>.GetUpper(): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"   value: ({string.Join(", ", values)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", upperResult)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
 
@@ -152,38 +160,46 @@ private void ValidateWithResult(Vector128<SByte> result, SByte[] values, [Caller
 
         private void ValidateWithResult(SByte[] result, SByte[] values, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             for (int i = 0; i < ElementCount / 2; i++)
             {
                 if (result[i] != values[i + (ElementCount / 2)])
                 {
-                    Succeeded = false;
+                    succeeded = false;
                     break;
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"Vector128<SByte.WithLower(): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"   value: ({string.Join(", ", values)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
 
+            succeeded = true;
+
             for (int i = ElementCount / 2; i < ElementCount; i++)
             {
                 if (result[i] != values[i - (ElementCount / 2)])
                 {
-                    Succeeded = false;
+                    succeeded = false;
                     break;
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"Vector128<SByte.WithUpper(): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"   value: ({string.Join(", ", values)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/General/Vector128_1/GetAndWithLowerAndUpper.Single.cs b/tests/src/JIT/HardwareIntrinsics/General/Vector128_1/GetAndWithLowerAndUpper.Single.cs
index e5920b124743..b91707566d52 100644
--- a/tests/src/JIT/HardwareIntrinsics/General/Vector128_1/GetAndWithLowerAndUpper.Single.cs
+++ b/tests/src/JIT/HardwareIntrinsics/General/Vector128_1/GetAndWithLowerAndUpper.Single.cs
@@ -108,38 +108,46 @@ private void ValidateGetResult(Vector64<Single> lowerResult, Vector64<Single> up
 
         private void ValidateGetResult(Single[] lowerResult, Single[] upperResult, Single[] values, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             for (int i = 0; i < ElementCount / 2; i++)
             {
                 if (lowerResult[i] != values[i])
                 {
-                    Succeeded = false;
+                    succeeded = false;
                     break;
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"Vector128<Single>.GetLower(): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"   value: ({string.Join(", ", values)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", lowerResult)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
 
+            succeeded = true;
+
             for (int i = ElementCount / 2; i < ElementCount; i++)
             {
                 if (upperResult[i - (ElementCount / 2)] != values[i])
                 {
-                    Succeeded = false;
+                    succeeded = false;
                     break;
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"Vector128<Single>.GetUpper(): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"   value: ({string.Join(", ", values)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", upperResult)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
 
@@ -152,38 +160,46 @@ private void ValidateWithResult(Vector128<Single> result, Single[] values, [Call
 
         private void ValidateWithResult(Single[] result, Single[] values, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             for (int i = 0; i < ElementCount / 2; i++)
             {
                 if (result[i] != values[i + (ElementCount / 2)])
                 {
-                    Succeeded = false;
+                    succeeded = false;
                     break;
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"Vector128<Single.WithLower(): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"   value: ({string.Join(", ", values)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
 
+            succeeded = true;
+
             for (int i = ElementCount / 2; i < ElementCount; i++)
             {
                 if (result[i] != values[i - (ElementCount / 2)])
                 {
-                    Succeeded = false;
+                    succeeded = false;
                     break;
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"Vector128<Single.WithUpper(): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"   value: ({string.Join(", ", values)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/General/Vector128_1/GetAndWithLowerAndUpper.UInt16.cs b/tests/src/JIT/HardwareIntrinsics/General/Vector128_1/GetAndWithLowerAndUpper.UInt16.cs
index fd18b77d7916..8599aba7dd9b 100644
--- a/tests/src/JIT/HardwareIntrinsics/General/Vector128_1/GetAndWithLowerAndUpper.UInt16.cs
+++ b/tests/src/JIT/HardwareIntrinsics/General/Vector128_1/GetAndWithLowerAndUpper.UInt16.cs
@@ -108,38 +108,46 @@ private void ValidateGetResult(Vector64<UInt16> lowerResult, Vector64<UInt16> up
 
         private void ValidateGetResult(UInt16[] lowerResult, UInt16[] upperResult, UInt16[] values, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             for (int i = 0; i < ElementCount / 2; i++)
             {
                 if (lowerResult[i] != values[i])
                 {
-                    Succeeded = false;
+                    succeeded = false;
                     break;
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"Vector128<UInt16>.GetLower(): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"   value: ({string.Join(", ", values)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", lowerResult)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
 
+            succeeded = true;
+
             for (int i = ElementCount / 2; i < ElementCount; i++)
             {
                 if (upperResult[i - (ElementCount / 2)] != values[i])
                 {
-                    Succeeded = false;
+                    succeeded = false;
                     break;
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"Vector128<UInt16>.GetUpper(): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"   value: ({string.Join(", ", values)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", upperResult)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
 
@@ -152,38 +160,46 @@ private void ValidateWithResult(Vector128<UInt16> result, UInt16[] values, [Call
 
         private void ValidateWithResult(UInt16[] result, UInt16[] values, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             for (int i = 0; i < ElementCount / 2; i++)
             {
                 if (result[i] != values[i + (ElementCount / 2)])
                 {
-                    Succeeded = false;
+                    succeeded = false;
                     break;
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"Vector128<UInt16.WithLower(): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"   value: ({string.Join(", ", values)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
 
+            succeeded = true;
+
             for (int i = ElementCount / 2; i < ElementCount; i++)
             {
                 if (result[i] != values[i - (ElementCount / 2)])
                 {
-                    Succeeded = false;
+                    succeeded = false;
                     break;
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"Vector128<UInt16.WithUpper(): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"   value: ({string.Join(", ", values)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/General/Vector128_1/GetAndWithLowerAndUpper.UInt32.cs b/tests/src/JIT/HardwareIntrinsics/General/Vector128_1/GetAndWithLowerAndUpper.UInt32.cs
index 64bce168b119..40ec5736d881 100644
--- a/tests/src/JIT/HardwareIntrinsics/General/Vector128_1/GetAndWithLowerAndUpper.UInt32.cs
+++ b/tests/src/JIT/HardwareIntrinsics/General/Vector128_1/GetAndWithLowerAndUpper.UInt32.cs
@@ -108,38 +108,46 @@ private void ValidateGetResult(Vector64<UInt32> lowerResult, Vector64<UInt32> up
 
         private void ValidateGetResult(UInt32[] lowerResult, UInt32[] upperResult, UInt32[] values, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             for (int i = 0; i < ElementCount / 2; i++)
             {
                 if (lowerResult[i] != values[i])
                 {
-                    Succeeded = false;
+                    succeeded = false;
                     break;
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"Vector128<UInt32>.GetLower(): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"   value: ({string.Join(", ", values)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", lowerResult)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
 
+            succeeded = true;
+
             for (int i = ElementCount / 2; i < ElementCount; i++)
             {
                 if (upperResult[i - (ElementCount / 2)] != values[i])
                 {
-                    Succeeded = false;
+                    succeeded = false;
                     break;
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"Vector128<UInt32>.GetUpper(): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"   value: ({string.Join(", ", values)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", upperResult)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
 
@@ -152,38 +160,46 @@ private void ValidateWithResult(Vector128<UInt32> result, UInt32[] values, [Call
 
         private void ValidateWithResult(UInt32[] result, UInt32[] values, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             for (int i = 0; i < ElementCount / 2; i++)
             {
                 if (result[i] != values[i + (ElementCount / 2)])
                 {
-                    Succeeded = false;
+                    succeeded = false;
                     break;
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"Vector128<UInt32.WithLower(): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"   value: ({string.Join(", ", values)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
 
+            succeeded = true;
+
             for (int i = ElementCount / 2; i < ElementCount; i++)
             {
                 if (result[i] != values[i - (ElementCount / 2)])
                 {
-                    Succeeded = false;
+                    succeeded = false;
                     break;
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"Vector128<UInt32.WithUpper(): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"   value: ({string.Join(", ", values)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/General/Vector128_1/GetAndWithLowerAndUpper.UInt64.cs b/tests/src/JIT/HardwareIntrinsics/General/Vector128_1/GetAndWithLowerAndUpper.UInt64.cs
index cf3d7b710fbf..e7d03740edd6 100644
--- a/tests/src/JIT/HardwareIntrinsics/General/Vector128_1/GetAndWithLowerAndUpper.UInt64.cs
+++ b/tests/src/JIT/HardwareIntrinsics/General/Vector128_1/GetAndWithLowerAndUpper.UInt64.cs
@@ -108,38 +108,46 @@ private void ValidateGetResult(Vector64<UInt64> lowerResult, Vector64<UInt64> up
 
         private void ValidateGetResult(UInt64[] lowerResult, UInt64[] upperResult, UInt64[] values, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             for (int i = 0; i < ElementCount / 2; i++)
             {
                 if (lowerResult[i] != values[i])
                 {
-                    Succeeded = false;
+                    succeeded = false;
                     break;
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"Vector128<UInt64>.GetLower(): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"   value: ({string.Join(", ", values)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", lowerResult)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
 
+            succeeded = true;
+
             for (int i = ElementCount / 2; i < ElementCount; i++)
             {
                 if (upperResult[i - (ElementCount / 2)] != values[i])
                 {
-                    Succeeded = false;
+                    succeeded = false;
                     break;
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"Vector128<UInt64>.GetUpper(): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"   value: ({string.Join(", ", values)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", upperResult)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
 
@@ -152,38 +160,46 @@ private void ValidateWithResult(Vector128<UInt64> result, UInt64[] values, [Call
 
         private void ValidateWithResult(UInt64[] result, UInt64[] values, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             for (int i = 0; i < ElementCount / 2; i++)
             {
                 if (result[i] != values[i + (ElementCount / 2)])
                 {
-                    Succeeded = false;
+                    succeeded = false;
                     break;
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"Vector128<UInt64.WithLower(): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"   value: ({string.Join(", ", values)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
 
+            succeeded = true;
+
             for (int i = ElementCount / 2; i < ElementCount; i++)
             {
                 if (result[i] != values[i - (ElementCount / 2)])
                 {
-                    Succeeded = false;
+                    succeeded = false;
                     break;
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"Vector128<UInt64.WithUpper(): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"   value: ({string.Join(", ", values)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/General/Vector128_1/ToScalar.Byte.cs b/tests/src/JIT/HardwareIntrinsics/General/Vector128_1/ToScalar.Byte.cs
index 75cbf712f8c5..2c1310ebda01 100644
--- a/tests/src/JIT/HardwareIntrinsics/General/Vector128_1/ToScalar.Byte.cs
+++ b/tests/src/JIT/HardwareIntrinsics/General/Vector128_1/ToScalar.Byte.cs
@@ -84,12 +84,12 @@ private void ValidateResult(Byte result, Byte[] values, [CallerMemberName] strin
         {
             if (result != values[0])
             {
-                Succeeded = false;
-
                 TestLibrary.TestFramework.LogInformation($"Vector128<Byte>.ToScalar(): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"  values: ({string.Join(", ", values)})");
                 TestLibrary.TestFramework.LogInformation($"  result: {result}");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/General/Vector128_1/ToScalar.Double.cs b/tests/src/JIT/HardwareIntrinsics/General/Vector128_1/ToScalar.Double.cs
index 471b8a336cff..db83ccfcf9b3 100644
--- a/tests/src/JIT/HardwareIntrinsics/General/Vector128_1/ToScalar.Double.cs
+++ b/tests/src/JIT/HardwareIntrinsics/General/Vector128_1/ToScalar.Double.cs
@@ -84,12 +84,12 @@ private void ValidateResult(Double result, Double[] values, [CallerMemberName] s
         {
             if (result != values[0])
             {
-                Succeeded = false;
-
                 TestLibrary.TestFramework.LogInformation($"Vector128<Double>.ToScalar(): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"  values: ({string.Join(", ", values)})");
                 TestLibrary.TestFramework.LogInformation($"  result: {result}");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/General/Vector128_1/ToScalar.Int16.cs b/tests/src/JIT/HardwareIntrinsics/General/Vector128_1/ToScalar.Int16.cs
index 54777c958950..c91796c69f87 100644
--- a/tests/src/JIT/HardwareIntrinsics/General/Vector128_1/ToScalar.Int16.cs
+++ b/tests/src/JIT/HardwareIntrinsics/General/Vector128_1/ToScalar.Int16.cs
@@ -84,12 +84,12 @@ private void ValidateResult(Int16 result, Int16[] values, [CallerMemberName] str
         {
             if (result != values[0])
             {
-                Succeeded = false;
-
                 TestLibrary.TestFramework.LogInformation($"Vector128<Int16>.ToScalar(): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"  values: ({string.Join(", ", values)})");
                 TestLibrary.TestFramework.LogInformation($"  result: {result}");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/General/Vector128_1/ToScalar.Int32.cs b/tests/src/JIT/HardwareIntrinsics/General/Vector128_1/ToScalar.Int32.cs
index 4ba00f97921d..47e49ff0be5a 100644
--- a/tests/src/JIT/HardwareIntrinsics/General/Vector128_1/ToScalar.Int32.cs
+++ b/tests/src/JIT/HardwareIntrinsics/General/Vector128_1/ToScalar.Int32.cs
@@ -84,12 +84,12 @@ private void ValidateResult(Int32 result, Int32[] values, [CallerMemberName] str
         {
             if (result != values[0])
             {
-                Succeeded = false;
-
                 TestLibrary.TestFramework.LogInformation($"Vector128<Int32>.ToScalar(): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"  values: ({string.Join(", ", values)})");
                 TestLibrary.TestFramework.LogInformation($"  result: {result}");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/General/Vector128_1/ToScalar.Int64.cs b/tests/src/JIT/HardwareIntrinsics/General/Vector128_1/ToScalar.Int64.cs
index f3e2d1faac55..536ddda7ec95 100644
--- a/tests/src/JIT/HardwareIntrinsics/General/Vector128_1/ToScalar.Int64.cs
+++ b/tests/src/JIT/HardwareIntrinsics/General/Vector128_1/ToScalar.Int64.cs
@@ -84,12 +84,12 @@ private void ValidateResult(Int64 result, Int64[] values, [CallerMemberName] str
         {
             if (result != values[0])
             {
-                Succeeded = false;
-
                 TestLibrary.TestFramework.LogInformation($"Vector128<Int64>.ToScalar(): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"  values: ({string.Join(", ", values)})");
                 TestLibrary.TestFramework.LogInformation($"  result: {result}");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/General/Vector128_1/ToScalar.SByte.cs b/tests/src/JIT/HardwareIntrinsics/General/Vector128_1/ToScalar.SByte.cs
index db795978a3a3..21904361bc1d 100644
--- a/tests/src/JIT/HardwareIntrinsics/General/Vector128_1/ToScalar.SByte.cs
+++ b/tests/src/JIT/HardwareIntrinsics/General/Vector128_1/ToScalar.SByte.cs
@@ -84,12 +84,12 @@ private void ValidateResult(SByte result, SByte[] values, [CallerMemberName] str
         {
             if (result != values[0])
             {
-                Succeeded = false;
-
                 TestLibrary.TestFramework.LogInformation($"Vector128<SByte>.ToScalar(): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"  values: ({string.Join(", ", values)})");
                 TestLibrary.TestFramework.LogInformation($"  result: {result}");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/General/Vector128_1/ToScalar.Single.cs b/tests/src/JIT/HardwareIntrinsics/General/Vector128_1/ToScalar.Single.cs
index 683987cba82a..b763072c845f 100644
--- a/tests/src/JIT/HardwareIntrinsics/General/Vector128_1/ToScalar.Single.cs
+++ b/tests/src/JIT/HardwareIntrinsics/General/Vector128_1/ToScalar.Single.cs
@@ -84,12 +84,12 @@ private void ValidateResult(Single result, Single[] values, [CallerMemberName] s
         {
             if (result != values[0])
             {
-                Succeeded = false;
-
                 TestLibrary.TestFramework.LogInformation($"Vector128<Single>.ToScalar(): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"  values: ({string.Join(", ", values)})");
                 TestLibrary.TestFramework.LogInformation($"  result: {result}");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/General/Vector128_1/ToScalar.UInt16.cs b/tests/src/JIT/HardwareIntrinsics/General/Vector128_1/ToScalar.UInt16.cs
index cfd8a6e65a7c..d9a591d4b587 100644
--- a/tests/src/JIT/HardwareIntrinsics/General/Vector128_1/ToScalar.UInt16.cs
+++ b/tests/src/JIT/HardwareIntrinsics/General/Vector128_1/ToScalar.UInt16.cs
@@ -84,12 +84,12 @@ private void ValidateResult(UInt16 result, UInt16[] values, [CallerMemberName] s
         {
             if (result != values[0])
             {
-                Succeeded = false;
-
                 TestLibrary.TestFramework.LogInformation($"Vector128<UInt16>.ToScalar(): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"  values: ({string.Join(", ", values)})");
                 TestLibrary.TestFramework.LogInformation($"  result: {result}");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/General/Vector128_1/ToScalar.UInt32.cs b/tests/src/JIT/HardwareIntrinsics/General/Vector128_1/ToScalar.UInt32.cs
index 912e3acb369b..e0950847f4b1 100644
--- a/tests/src/JIT/HardwareIntrinsics/General/Vector128_1/ToScalar.UInt32.cs
+++ b/tests/src/JIT/HardwareIntrinsics/General/Vector128_1/ToScalar.UInt32.cs
@@ -84,12 +84,12 @@ private void ValidateResult(UInt32 result, UInt32[] values, [CallerMemberName] s
         {
             if (result != values[0])
             {
-                Succeeded = false;
-
                 TestLibrary.TestFramework.LogInformation($"Vector128<UInt32>.ToScalar(): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"  values: ({string.Join(", ", values)})");
                 TestLibrary.TestFramework.LogInformation($"  result: {result}");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/General/Vector128_1/ToScalar.UInt64.cs b/tests/src/JIT/HardwareIntrinsics/General/Vector128_1/ToScalar.UInt64.cs
index c73eb28510be..bb4b26921aff 100644
--- a/tests/src/JIT/HardwareIntrinsics/General/Vector128_1/ToScalar.UInt64.cs
+++ b/tests/src/JIT/HardwareIntrinsics/General/Vector128_1/ToScalar.UInt64.cs
@@ -84,12 +84,12 @@ private void ValidateResult(UInt64 result, UInt64[] values, [CallerMemberName] s
         {
             if (result != values[0])
             {
-                Succeeded = false;
-
                 TestLibrary.TestFramework.LogInformation($"Vector128<UInt64>.ToScalar(): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"  values: ({string.Join(", ", values)})");
                 TestLibrary.TestFramework.LogInformation($"  result: {result}");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/General/Vector128_1/ToVector256.Byte.cs b/tests/src/JIT/HardwareIntrinsics/General/Vector128_1/ToVector256.Byte.cs
index 3ac4bd5cf4dc..00ccea8ffb9d 100644
--- a/tests/src/JIT/HardwareIntrinsics/General/Vector128_1/ToVector256.Byte.cs
+++ b/tests/src/JIT/HardwareIntrinsics/General/Vector128_1/ToVector256.Byte.cs
@@ -97,11 +97,13 @@ private void ValidateResult(Vector256<Byte> result, Byte[] values, bool isUnsafe
 
         private void ValidateResult(Byte[] result, Byte[] values, bool isUnsafe, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             for (int i = 0; i < ElementCount; i++)
             {
                 if (result[i] != values[i])
                 {
-                    Succeeded = false;
+                    succeeded = false;
                     break;
                 }
             }
@@ -112,18 +114,20 @@ private void ValidateResult(Byte[] result, Byte[] values, bool isUnsafe, [Caller
                 {
                     if (result[i] != 0)
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"Vector128<Byte>.ToVector256{(isUnsafe ? "Unsafe" : "")}(): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"   value: ({string.Join(", ", values)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/General/Vector128_1/ToVector256.Double.cs b/tests/src/JIT/HardwareIntrinsics/General/Vector128_1/ToVector256.Double.cs
index a3d553b3c5c6..63cc2195e48f 100644
--- a/tests/src/JIT/HardwareIntrinsics/General/Vector128_1/ToVector256.Double.cs
+++ b/tests/src/JIT/HardwareIntrinsics/General/Vector128_1/ToVector256.Double.cs
@@ -97,11 +97,13 @@ private void ValidateResult(Vector256<Double> result, Double[] values, bool isUn
 
         private void ValidateResult(Double[] result, Double[] values, bool isUnsafe, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             for (int i = 0; i < ElementCount; i++)
             {
                 if (result[i] != values[i])
                 {
-                    Succeeded = false;
+                    succeeded = false;
                     break;
                 }
             }
@@ -112,18 +114,20 @@ private void ValidateResult(Double[] result, Double[] values, bool isUnsafe, [Ca
                 {
                     if (result[i] != 0)
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"Vector128<Double>.ToVector256{(isUnsafe ? "Unsafe" : "")}(): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"   value: ({string.Join(", ", values)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/General/Vector128_1/ToVector256.Int16.cs b/tests/src/JIT/HardwareIntrinsics/General/Vector128_1/ToVector256.Int16.cs
index ab1798923299..4b797f011210 100644
--- a/tests/src/JIT/HardwareIntrinsics/General/Vector128_1/ToVector256.Int16.cs
+++ b/tests/src/JIT/HardwareIntrinsics/General/Vector128_1/ToVector256.Int16.cs
@@ -97,11 +97,13 @@ private void ValidateResult(Vector256<Int16> result, Int16[] values, bool isUnsa
 
         private void ValidateResult(Int16[] result, Int16[] values, bool isUnsafe, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             for (int i = 0; i < ElementCount; i++)
             {
                 if (result[i] != values[i])
                 {
-                    Succeeded = false;
+                    succeeded = false;
                     break;
                 }
             }
@@ -112,18 +114,20 @@ private void ValidateResult(Int16[] result, Int16[] values, bool isUnsafe, [Call
                 {
                     if (result[i] != 0)
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"Vector128<Int16>.ToVector256{(isUnsafe ? "Unsafe" : "")}(): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"   value: ({string.Join(", ", values)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/General/Vector128_1/ToVector256.Int32.cs b/tests/src/JIT/HardwareIntrinsics/General/Vector128_1/ToVector256.Int32.cs
index c111973b532f..42edfdac1de7 100644
--- a/tests/src/JIT/HardwareIntrinsics/General/Vector128_1/ToVector256.Int32.cs
+++ b/tests/src/JIT/HardwareIntrinsics/General/Vector128_1/ToVector256.Int32.cs
@@ -97,11 +97,13 @@ private void ValidateResult(Vector256<Int32> result, Int32[] values, bool isUnsa
 
         private void ValidateResult(Int32[] result, Int32[] values, bool isUnsafe, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             for (int i = 0; i < ElementCount; i++)
             {
                 if (result[i] != values[i])
                 {
-                    Succeeded = false;
+                    succeeded = false;
                     break;
                 }
             }
@@ -112,18 +114,20 @@ private void ValidateResult(Int32[] result, Int32[] values, bool isUnsafe, [Call
                 {
                     if (result[i] != 0)
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"Vector128<Int32>.ToVector256{(isUnsafe ? "Unsafe" : "")}(): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"   value: ({string.Join(", ", values)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/General/Vector128_1/ToVector256.Int64.cs b/tests/src/JIT/HardwareIntrinsics/General/Vector128_1/ToVector256.Int64.cs
index 4d0b9313fd09..2eae2d069ab3 100644
--- a/tests/src/JIT/HardwareIntrinsics/General/Vector128_1/ToVector256.Int64.cs
+++ b/tests/src/JIT/HardwareIntrinsics/General/Vector128_1/ToVector256.Int64.cs
@@ -97,11 +97,13 @@ private void ValidateResult(Vector256<Int64> result, Int64[] values, bool isUnsa
 
         private void ValidateResult(Int64[] result, Int64[] values, bool isUnsafe, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             for (int i = 0; i < ElementCount; i++)
             {
                 if (result[i] != values[i])
                 {
-                    Succeeded = false;
+                    succeeded = false;
                     break;
                 }
             }
@@ -112,18 +114,20 @@ private void ValidateResult(Int64[] result, Int64[] values, bool isUnsafe, [Call
                 {
                     if (result[i] != 0)
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"Vector128<Int64>.ToVector256{(isUnsafe ? "Unsafe" : "")}(): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"   value: ({string.Join(", ", values)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/General/Vector128_1/ToVector256.SByte.cs b/tests/src/JIT/HardwareIntrinsics/General/Vector128_1/ToVector256.SByte.cs
index 247735903c12..fcf945d66040 100644
--- a/tests/src/JIT/HardwareIntrinsics/General/Vector128_1/ToVector256.SByte.cs
+++ b/tests/src/JIT/HardwareIntrinsics/General/Vector128_1/ToVector256.SByte.cs
@@ -97,11 +97,13 @@ private void ValidateResult(Vector256<SByte> result, SByte[] values, bool isUnsa
 
         private void ValidateResult(SByte[] result, SByte[] values, bool isUnsafe, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             for (int i = 0; i < ElementCount; i++)
             {
                 if (result[i] != values[i])
                 {
-                    Succeeded = false;
+                    succeeded = false;
                     break;
                 }
             }
@@ -112,18 +114,20 @@ private void ValidateResult(SByte[] result, SByte[] values, bool isUnsafe, [Call
                 {
                     if (result[i] != 0)
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"Vector128<SByte>.ToVector256{(isUnsafe ? "Unsafe" : "")}(): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"   value: ({string.Join(", ", values)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/General/Vector128_1/ToVector256.Single.cs b/tests/src/JIT/HardwareIntrinsics/General/Vector128_1/ToVector256.Single.cs
index 674dee6091ba..46f68a2a3d0c 100644
--- a/tests/src/JIT/HardwareIntrinsics/General/Vector128_1/ToVector256.Single.cs
+++ b/tests/src/JIT/HardwareIntrinsics/General/Vector128_1/ToVector256.Single.cs
@@ -97,11 +97,13 @@ private void ValidateResult(Vector256<Single> result, Single[] values, bool isUn
 
         private void ValidateResult(Single[] result, Single[] values, bool isUnsafe, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             for (int i = 0; i < ElementCount; i++)
             {
                 if (result[i] != values[i])
                 {
-                    Succeeded = false;
+                    succeeded = false;
                     break;
                 }
             }
@@ -112,18 +114,20 @@ private void ValidateResult(Single[] result, Single[] values, bool isUnsafe, [Ca
                 {
                     if (result[i] != 0)
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"Vector128<Single>.ToVector256{(isUnsafe ? "Unsafe" : "")}(): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"   value: ({string.Join(", ", values)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/General/Vector128_1/ToVector256.UInt16.cs b/tests/src/JIT/HardwareIntrinsics/General/Vector128_1/ToVector256.UInt16.cs
index 9761b39724e6..8a087e4b3df2 100644
--- a/tests/src/JIT/HardwareIntrinsics/General/Vector128_1/ToVector256.UInt16.cs
+++ b/tests/src/JIT/HardwareIntrinsics/General/Vector128_1/ToVector256.UInt16.cs
@@ -97,11 +97,13 @@ private void ValidateResult(Vector256<UInt16> result, UInt16[] values, bool isUn
 
         private void ValidateResult(UInt16[] result, UInt16[] values, bool isUnsafe, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             for (int i = 0; i < ElementCount; i++)
             {
                 if (result[i] != values[i])
                 {
-                    Succeeded = false;
+                    succeeded = false;
                     break;
                 }
             }
@@ -112,18 +114,20 @@ private void ValidateResult(UInt16[] result, UInt16[] values, bool isUnsafe, [Ca
                 {
                     if (result[i] != 0)
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"Vector128<UInt16>.ToVector256{(isUnsafe ? "Unsafe" : "")}(): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"   value: ({string.Join(", ", values)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/General/Vector128_1/ToVector256.UInt32.cs b/tests/src/JIT/HardwareIntrinsics/General/Vector128_1/ToVector256.UInt32.cs
index df2df66a0bb5..0626021e882c 100644
--- a/tests/src/JIT/HardwareIntrinsics/General/Vector128_1/ToVector256.UInt32.cs
+++ b/tests/src/JIT/HardwareIntrinsics/General/Vector128_1/ToVector256.UInt32.cs
@@ -97,11 +97,13 @@ private void ValidateResult(Vector256<UInt32> result, UInt32[] values, bool isUn
 
         private void ValidateResult(UInt32[] result, UInt32[] values, bool isUnsafe, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             for (int i = 0; i < ElementCount; i++)
             {
                 if (result[i] != values[i])
                 {
-                    Succeeded = false;
+                    succeeded = false;
                     break;
                 }
             }
@@ -112,18 +114,20 @@ private void ValidateResult(UInt32[] result, UInt32[] values, bool isUnsafe, [Ca
                 {
                     if (result[i] != 0)
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"Vector128<UInt32>.ToVector256{(isUnsafe ? "Unsafe" : "")}(): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"   value: ({string.Join(", ", values)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/General/Vector128_1/ToVector256.UInt64.cs b/tests/src/JIT/HardwareIntrinsics/General/Vector128_1/ToVector256.UInt64.cs
index 987b927eed67..f75c9895e83e 100644
--- a/tests/src/JIT/HardwareIntrinsics/General/Vector128_1/ToVector256.UInt64.cs
+++ b/tests/src/JIT/HardwareIntrinsics/General/Vector128_1/ToVector256.UInt64.cs
@@ -97,11 +97,13 @@ private void ValidateResult(Vector256<UInt64> result, UInt64[] values, bool isUn
 
         private void ValidateResult(UInt64[] result, UInt64[] values, bool isUnsafe, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             for (int i = 0; i < ElementCount; i++)
             {
                 if (result[i] != values[i])
                 {
-                    Succeeded = false;
+                    succeeded = false;
                     break;
                 }
             }
@@ -112,18 +114,20 @@ private void ValidateResult(UInt64[] result, UInt64[] values, bool isUnsafe, [Ca
                 {
                     if (result[i] != 0)
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"Vector128<UInt64>.ToVector256{(isUnsafe ? "Unsafe" : "")}(): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"   value: ({string.Join(", ", values)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/General/Vector128_1/Zero.Byte.cs b/tests/src/JIT/HardwareIntrinsics/General/Vector128_1/Zero.Byte.cs
index c9bee9a3526d..d87067c25095 100644
--- a/tests/src/JIT/HardwareIntrinsics/General/Vector128_1/Zero.Byte.cs
+++ b/tests/src/JIT/HardwareIntrinsics/General/Vector128_1/Zero.Byte.cs
@@ -73,20 +73,24 @@ private void ValidateResult(Vector128<Byte> result, [CallerMemberName] string me
 
         private void ValidateResult(Byte[] resultElements, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+        
             for (var i = 0; i < ElementCount; i++)
             {
                 if (resultElements[i] != 0)
                 {
-                    Succeeded = false;
+                    succeeded = false;
                     break;
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"Vector128.Zero(Byte): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", resultElements)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/General/Vector128_1/Zero.Double.cs b/tests/src/JIT/HardwareIntrinsics/General/Vector128_1/Zero.Double.cs
index c874641e07f5..0af1cf45c01e 100644
--- a/tests/src/JIT/HardwareIntrinsics/General/Vector128_1/Zero.Double.cs
+++ b/tests/src/JIT/HardwareIntrinsics/General/Vector128_1/Zero.Double.cs
@@ -73,20 +73,24 @@ private void ValidateResult(Vector128<Double> result, [CallerMemberName] string
 
         private void ValidateResult(Double[] resultElements, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+        
             for (var i = 0; i < ElementCount; i++)
             {
                 if (resultElements[i] != 0)
                 {
-                    Succeeded = false;
+                    succeeded = false;
                     break;
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"Vector128.Zero(Double): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", resultElements)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/General/Vector128_1/Zero.Int16.cs b/tests/src/JIT/HardwareIntrinsics/General/Vector128_1/Zero.Int16.cs
index 896806f71366..81957f247b3c 100644
--- a/tests/src/JIT/HardwareIntrinsics/General/Vector128_1/Zero.Int16.cs
+++ b/tests/src/JIT/HardwareIntrinsics/General/Vector128_1/Zero.Int16.cs
@@ -73,20 +73,24 @@ private void ValidateResult(Vector128<Int16> result, [CallerMemberName] string m
 
         private void ValidateResult(Int16[] resultElements, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+        
             for (var i = 0; i < ElementCount; i++)
             {
                 if (resultElements[i] != 0)
                 {
-                    Succeeded = false;
+                    succeeded = false;
                     break;
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"Vector128.Zero(Int16): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", resultElements)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/General/Vector128_1/Zero.Int32.cs b/tests/src/JIT/HardwareIntrinsics/General/Vector128_1/Zero.Int32.cs
index 1a68bbeab90d..398c13260cab 100644
--- a/tests/src/JIT/HardwareIntrinsics/General/Vector128_1/Zero.Int32.cs
+++ b/tests/src/JIT/HardwareIntrinsics/General/Vector128_1/Zero.Int32.cs
@@ -73,20 +73,24 @@ private void ValidateResult(Vector128<Int32> result, [CallerMemberName] string m
 
         private void ValidateResult(Int32[] resultElements, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+        
             for (var i = 0; i < ElementCount; i++)
             {
                 if (resultElements[i] != 0)
                 {
-                    Succeeded = false;
+                    succeeded = false;
                     break;
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"Vector128.Zero(Int32): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", resultElements)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/General/Vector128_1/Zero.Int64.cs b/tests/src/JIT/HardwareIntrinsics/General/Vector128_1/Zero.Int64.cs
index 4b1ed7656b5d..c4b180f0aa16 100644
--- a/tests/src/JIT/HardwareIntrinsics/General/Vector128_1/Zero.Int64.cs
+++ b/tests/src/JIT/HardwareIntrinsics/General/Vector128_1/Zero.Int64.cs
@@ -73,20 +73,24 @@ private void ValidateResult(Vector128<Int64> result, [CallerMemberName] string m
 
         private void ValidateResult(Int64[] resultElements, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+        
             for (var i = 0; i < ElementCount; i++)
             {
                 if (resultElements[i] != 0)
                 {
-                    Succeeded = false;
+                    succeeded = false;
                     break;
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"Vector128.Zero(Int64): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", resultElements)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/General/Vector128_1/Zero.SByte.cs b/tests/src/JIT/HardwareIntrinsics/General/Vector128_1/Zero.SByte.cs
index 14d59b20c898..258116721377 100644
--- a/tests/src/JIT/HardwareIntrinsics/General/Vector128_1/Zero.SByte.cs
+++ b/tests/src/JIT/HardwareIntrinsics/General/Vector128_1/Zero.SByte.cs
@@ -73,20 +73,24 @@ private void ValidateResult(Vector128<SByte> result, [CallerMemberName] string m
 
         private void ValidateResult(SByte[] resultElements, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+        
             for (var i = 0; i < ElementCount; i++)
             {
                 if (resultElements[i] != 0)
                 {
-                    Succeeded = false;
+                    succeeded = false;
                     break;
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"Vector128.Zero(SByte): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", resultElements)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/General/Vector128_1/Zero.Single.cs b/tests/src/JIT/HardwareIntrinsics/General/Vector128_1/Zero.Single.cs
index a734db183b73..f5eee1b2ac04 100644
--- a/tests/src/JIT/HardwareIntrinsics/General/Vector128_1/Zero.Single.cs
+++ b/tests/src/JIT/HardwareIntrinsics/General/Vector128_1/Zero.Single.cs
@@ -73,20 +73,24 @@ private void ValidateResult(Vector128<Single> result, [CallerMemberName] string
 
         private void ValidateResult(Single[] resultElements, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+        
             for (var i = 0; i < ElementCount; i++)
             {
                 if (resultElements[i] != 0)
                 {
-                    Succeeded = false;
+                    succeeded = false;
                     break;
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"Vector128.Zero(Single): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", resultElements)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/General/Vector128_1/Zero.UInt16.cs b/tests/src/JIT/HardwareIntrinsics/General/Vector128_1/Zero.UInt16.cs
index 8aa3b9b31154..f6e926d52598 100644
--- a/tests/src/JIT/HardwareIntrinsics/General/Vector128_1/Zero.UInt16.cs
+++ b/tests/src/JIT/HardwareIntrinsics/General/Vector128_1/Zero.UInt16.cs
@@ -73,20 +73,24 @@ private void ValidateResult(Vector128<UInt16> result, [CallerMemberName] string
 
         private void ValidateResult(UInt16[] resultElements, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+        
             for (var i = 0; i < ElementCount; i++)
             {
                 if (resultElements[i] != 0)
                 {
-                    Succeeded = false;
+                    succeeded = false;
                     break;
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"Vector128.Zero(UInt16): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", resultElements)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/General/Vector128_1/Zero.UInt32.cs b/tests/src/JIT/HardwareIntrinsics/General/Vector128_1/Zero.UInt32.cs
index 5d85256cc9cc..0aef26e19139 100644
--- a/tests/src/JIT/HardwareIntrinsics/General/Vector128_1/Zero.UInt32.cs
+++ b/tests/src/JIT/HardwareIntrinsics/General/Vector128_1/Zero.UInt32.cs
@@ -73,20 +73,24 @@ private void ValidateResult(Vector128<UInt32> result, [CallerMemberName] string
 
         private void ValidateResult(UInt32[] resultElements, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+        
             for (var i = 0; i < ElementCount; i++)
             {
                 if (resultElements[i] != 0)
                 {
-                    Succeeded = false;
+                    succeeded = false;
                     break;
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"Vector128.Zero(UInt32): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", resultElements)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/General/Vector128_1/Zero.UInt64.cs b/tests/src/JIT/HardwareIntrinsics/General/Vector128_1/Zero.UInt64.cs
index 544891b54dc8..e521928bd647 100644
--- a/tests/src/JIT/HardwareIntrinsics/General/Vector128_1/Zero.UInt64.cs
+++ b/tests/src/JIT/HardwareIntrinsics/General/Vector128_1/Zero.UInt64.cs
@@ -73,20 +73,24 @@ private void ValidateResult(Vector128<UInt64> result, [CallerMemberName] string
 
         private void ValidateResult(UInt64[] resultElements, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+        
             for (var i = 0; i < ElementCount; i++)
             {
                 if (resultElements[i] != 0)
                 {
-                    Succeeded = false;
+                    succeeded = false;
                     break;
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"Vector128.Zero(UInt64): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", resultElements)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/General/Vector256/Create.Byte.cs b/tests/src/JIT/HardwareIntrinsics/General/Vector256/Create.Byte.cs
index cf801d98c0f7..c9300b33405d 100644
--- a/tests/src/JIT/HardwareIntrinsics/General/Vector256/Create.Byte.cs
+++ b/tests/src/JIT/HardwareIntrinsics/General/Vector256/Create.Byte.cs
@@ -74,9 +74,11 @@ private void ValidateResult(Vector256<Byte> result, Byte expectedValue, [CallerM
 
         private void ValidateResult(Byte[] resultElements, Byte expectedValue, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (resultElements[0] != expectedValue)
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -84,18 +86,20 @@ private void ValidateResult(Byte[] resultElements, Byte expectedValue, [CallerMe
                 {
                     if (resultElements[i] != expectedValue)
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"Vector256.Create(Byte): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"   value: {expectedValue}");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", resultElements)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/General/Vector256/Create.Double.cs b/tests/src/JIT/HardwareIntrinsics/General/Vector256/Create.Double.cs
index d90d559f315f..b74e52c11a21 100644
--- a/tests/src/JIT/HardwareIntrinsics/General/Vector256/Create.Double.cs
+++ b/tests/src/JIT/HardwareIntrinsics/General/Vector256/Create.Double.cs
@@ -74,9 +74,11 @@ private void ValidateResult(Vector256<Double> result, Double expectedValue, [Cal
 
         private void ValidateResult(Double[] resultElements, Double expectedValue, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (resultElements[0] != expectedValue)
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -84,18 +86,20 @@ private void ValidateResult(Double[] resultElements, Double expectedValue, [Call
                 {
                     if (resultElements[i] != expectedValue)
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"Vector256.Create(Double): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"   value: {expectedValue}");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", resultElements)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/General/Vector256/Create.Int16.cs b/tests/src/JIT/HardwareIntrinsics/General/Vector256/Create.Int16.cs
index 8e2147599e45..dba04752384a 100644
--- a/tests/src/JIT/HardwareIntrinsics/General/Vector256/Create.Int16.cs
+++ b/tests/src/JIT/HardwareIntrinsics/General/Vector256/Create.Int16.cs
@@ -74,9 +74,11 @@ private void ValidateResult(Vector256<Int16> result, Int16 expectedValue, [Calle
 
         private void ValidateResult(Int16[] resultElements, Int16 expectedValue, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (resultElements[0] != expectedValue)
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -84,18 +86,20 @@ private void ValidateResult(Int16[] resultElements, Int16 expectedValue, [Caller
                 {
                     if (resultElements[i] != expectedValue)
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"Vector256.Create(Int16): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"   value: {expectedValue}");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", resultElements)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/General/Vector256/Create.Int32.cs b/tests/src/JIT/HardwareIntrinsics/General/Vector256/Create.Int32.cs
index 2d39b41cdf6e..0f9fb25b08b2 100644
--- a/tests/src/JIT/HardwareIntrinsics/General/Vector256/Create.Int32.cs
+++ b/tests/src/JIT/HardwareIntrinsics/General/Vector256/Create.Int32.cs
@@ -74,9 +74,11 @@ private void ValidateResult(Vector256<Int32> result, Int32 expectedValue, [Calle
 
         private void ValidateResult(Int32[] resultElements, Int32 expectedValue, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (resultElements[0] != expectedValue)
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -84,18 +86,20 @@ private void ValidateResult(Int32[] resultElements, Int32 expectedValue, [Caller
                 {
                     if (resultElements[i] != expectedValue)
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"Vector256.Create(Int32): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"   value: {expectedValue}");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", resultElements)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/General/Vector256/Create.Int64.cs b/tests/src/JIT/HardwareIntrinsics/General/Vector256/Create.Int64.cs
index 1fd8d6499ce5..13b1882107be 100644
--- a/tests/src/JIT/HardwareIntrinsics/General/Vector256/Create.Int64.cs
+++ b/tests/src/JIT/HardwareIntrinsics/General/Vector256/Create.Int64.cs
@@ -74,9 +74,11 @@ private void ValidateResult(Vector256<Int64> result, Int64 expectedValue, [Calle
 
         private void ValidateResult(Int64[] resultElements, Int64 expectedValue, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (resultElements[0] != expectedValue)
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -84,18 +86,20 @@ private void ValidateResult(Int64[] resultElements, Int64 expectedValue, [Caller
                 {
                     if (resultElements[i] != expectedValue)
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"Vector256.Create(Int64): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"   value: {expectedValue}");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", resultElements)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/General/Vector256/Create.SByte.cs b/tests/src/JIT/HardwareIntrinsics/General/Vector256/Create.SByte.cs
index 08768e116729..7ca19826f23d 100644
--- a/tests/src/JIT/HardwareIntrinsics/General/Vector256/Create.SByte.cs
+++ b/tests/src/JIT/HardwareIntrinsics/General/Vector256/Create.SByte.cs
@@ -74,9 +74,11 @@ private void ValidateResult(Vector256<SByte> result, SByte expectedValue, [Calle
 
         private void ValidateResult(SByte[] resultElements, SByte expectedValue, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (resultElements[0] != expectedValue)
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -84,18 +86,20 @@ private void ValidateResult(SByte[] resultElements, SByte expectedValue, [Caller
                 {
                     if (resultElements[i] != expectedValue)
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"Vector256.Create(SByte): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"   value: {expectedValue}");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", resultElements)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/General/Vector256/Create.Single.cs b/tests/src/JIT/HardwareIntrinsics/General/Vector256/Create.Single.cs
index 507ed26e5340..74610b3e9e0f 100644
--- a/tests/src/JIT/HardwareIntrinsics/General/Vector256/Create.Single.cs
+++ b/tests/src/JIT/HardwareIntrinsics/General/Vector256/Create.Single.cs
@@ -74,9 +74,11 @@ private void ValidateResult(Vector256<Single> result, Single expectedValue, [Cal
 
         private void ValidateResult(Single[] resultElements, Single expectedValue, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (resultElements[0] != expectedValue)
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -84,18 +86,20 @@ private void ValidateResult(Single[] resultElements, Single expectedValue, [Call
                 {
                     if (resultElements[i] != expectedValue)
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"Vector256.Create(Single): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"   value: {expectedValue}");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", resultElements)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/General/Vector256/Create.UInt16.cs b/tests/src/JIT/HardwareIntrinsics/General/Vector256/Create.UInt16.cs
index f81d47771be4..4bb6356b5452 100644
--- a/tests/src/JIT/HardwareIntrinsics/General/Vector256/Create.UInt16.cs
+++ b/tests/src/JIT/HardwareIntrinsics/General/Vector256/Create.UInt16.cs
@@ -74,9 +74,11 @@ private void ValidateResult(Vector256<UInt16> result, UInt16 expectedValue, [Cal
 
         private void ValidateResult(UInt16[] resultElements, UInt16 expectedValue, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (resultElements[0] != expectedValue)
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -84,18 +86,20 @@ private void ValidateResult(UInt16[] resultElements, UInt16 expectedValue, [Call
                 {
                     if (resultElements[i] != expectedValue)
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"Vector256.Create(UInt16): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"   value: {expectedValue}");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", resultElements)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/General/Vector256/Create.UInt32.cs b/tests/src/JIT/HardwareIntrinsics/General/Vector256/Create.UInt32.cs
index 2f2c7880ad10..3dc4063f0e8c 100644
--- a/tests/src/JIT/HardwareIntrinsics/General/Vector256/Create.UInt32.cs
+++ b/tests/src/JIT/HardwareIntrinsics/General/Vector256/Create.UInt32.cs
@@ -74,9 +74,11 @@ private void ValidateResult(Vector256<UInt32> result, UInt32 expectedValue, [Cal
 
         private void ValidateResult(UInt32[] resultElements, UInt32 expectedValue, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (resultElements[0] != expectedValue)
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -84,18 +86,20 @@ private void ValidateResult(UInt32[] resultElements, UInt32 expectedValue, [Call
                 {
                     if (resultElements[i] != expectedValue)
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"Vector256.Create(UInt32): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"   value: {expectedValue}");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", resultElements)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/General/Vector256/Create.UInt64.cs b/tests/src/JIT/HardwareIntrinsics/General/Vector256/Create.UInt64.cs
index 15b01afa4783..4fdb39a806f9 100644
--- a/tests/src/JIT/HardwareIntrinsics/General/Vector256/Create.UInt64.cs
+++ b/tests/src/JIT/HardwareIntrinsics/General/Vector256/Create.UInt64.cs
@@ -74,9 +74,11 @@ private void ValidateResult(Vector256<UInt64> result, UInt64 expectedValue, [Cal
 
         private void ValidateResult(UInt64[] resultElements, UInt64 expectedValue, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (resultElements[0] != expectedValue)
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -84,18 +86,20 @@ private void ValidateResult(UInt64[] resultElements, UInt64 expectedValue, [Call
                 {
                     if (resultElements[i] != expectedValue)
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"Vector256.Create(UInt64): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"   value: {expectedValue}");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", resultElements)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/General/Vector256/CreateElement.Byte.cs b/tests/src/JIT/HardwareIntrinsics/General/Vector256/CreateElement.Byte.cs
index e098284231db..ff68f5ccfc49 100644
--- a/tests/src/JIT/HardwareIntrinsics/General/Vector256/CreateElement.Byte.cs
+++ b/tests/src/JIT/HardwareIntrinsics/General/Vector256/CreateElement.Byte.cs
@@ -88,21 +88,25 @@ private void ValidateResult(Vector256<Byte> result, Byte[] expectedValues, [Call
 
         private void ValidateResult(Byte[] resultElements, Byte[] expectedValues, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             for (var i = 0; i < ElementCount; i++)
             {
                 if (resultElements[i] != expectedValues[i])
                 {
-                    Succeeded = false;
+                    succeeded = false;
                     break;
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"Vector256.Create(Byte): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"   value: ({string.Join(", ", expectedValues)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", resultElements)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/General/Vector256/CreateElement.Double.cs b/tests/src/JIT/HardwareIntrinsics/General/Vector256/CreateElement.Double.cs
index e78e15f6fa42..937e9ac712e0 100644
--- a/tests/src/JIT/HardwareIntrinsics/General/Vector256/CreateElement.Double.cs
+++ b/tests/src/JIT/HardwareIntrinsics/General/Vector256/CreateElement.Double.cs
@@ -88,21 +88,25 @@ private void ValidateResult(Vector256<Double> result, Double[] expectedValues, [
 
         private void ValidateResult(Double[] resultElements, Double[] expectedValues, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             for (var i = 0; i < ElementCount; i++)
             {
                 if (resultElements[i] != expectedValues[i])
                 {
-                    Succeeded = false;
+                    succeeded = false;
                     break;
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"Vector256.Create(Double): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"   value: ({string.Join(", ", expectedValues)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", resultElements)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/General/Vector256/CreateElement.Int16.cs b/tests/src/JIT/HardwareIntrinsics/General/Vector256/CreateElement.Int16.cs
index 83827307e7e9..9ec72822a1f4 100644
--- a/tests/src/JIT/HardwareIntrinsics/General/Vector256/CreateElement.Int16.cs
+++ b/tests/src/JIT/HardwareIntrinsics/General/Vector256/CreateElement.Int16.cs
@@ -88,21 +88,25 @@ private void ValidateResult(Vector256<Int16> result, Int16[] expectedValues, [Ca
 
         private void ValidateResult(Int16[] resultElements, Int16[] expectedValues, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             for (var i = 0; i < ElementCount; i++)
             {
                 if (resultElements[i] != expectedValues[i])
                 {
-                    Succeeded = false;
+                    succeeded = false;
                     break;
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"Vector256.Create(Int16): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"   value: ({string.Join(", ", expectedValues)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", resultElements)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/General/Vector256/CreateElement.Int32.cs b/tests/src/JIT/HardwareIntrinsics/General/Vector256/CreateElement.Int32.cs
index 1c0ab74f2fe4..83defc8a9972 100644
--- a/tests/src/JIT/HardwareIntrinsics/General/Vector256/CreateElement.Int32.cs
+++ b/tests/src/JIT/HardwareIntrinsics/General/Vector256/CreateElement.Int32.cs
@@ -88,21 +88,25 @@ private void ValidateResult(Vector256<Int32> result, Int32[] expectedValues, [Ca
 
         private void ValidateResult(Int32[] resultElements, Int32[] expectedValues, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             for (var i = 0; i < ElementCount; i++)
             {
                 if (resultElements[i] != expectedValues[i])
                 {
-                    Succeeded = false;
+                    succeeded = false;
                     break;
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"Vector256.Create(Int32): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"   value: ({string.Join(", ", expectedValues)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", resultElements)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/General/Vector256/CreateElement.Int64.cs b/tests/src/JIT/HardwareIntrinsics/General/Vector256/CreateElement.Int64.cs
index 6ef856953282..4c65b67c8e8c 100644
--- a/tests/src/JIT/HardwareIntrinsics/General/Vector256/CreateElement.Int64.cs
+++ b/tests/src/JIT/HardwareIntrinsics/General/Vector256/CreateElement.Int64.cs
@@ -88,21 +88,25 @@ private void ValidateResult(Vector256<Int64> result, Int64[] expectedValues, [Ca
 
         private void ValidateResult(Int64[] resultElements, Int64[] expectedValues, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             for (var i = 0; i < ElementCount; i++)
             {
                 if (resultElements[i] != expectedValues[i])
                 {
-                    Succeeded = false;
+                    succeeded = false;
                     break;
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"Vector256.Create(Int64): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"   value: ({string.Join(", ", expectedValues)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", resultElements)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/General/Vector256/CreateElement.SByte.cs b/tests/src/JIT/HardwareIntrinsics/General/Vector256/CreateElement.SByte.cs
index 95e4d16b74e4..b738b3b6f4f3 100644
--- a/tests/src/JIT/HardwareIntrinsics/General/Vector256/CreateElement.SByte.cs
+++ b/tests/src/JIT/HardwareIntrinsics/General/Vector256/CreateElement.SByte.cs
@@ -88,21 +88,25 @@ private void ValidateResult(Vector256<SByte> result, SByte[] expectedValues, [Ca
 
         private void ValidateResult(SByte[] resultElements, SByte[] expectedValues, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             for (var i = 0; i < ElementCount; i++)
             {
                 if (resultElements[i] != expectedValues[i])
                 {
-                    Succeeded = false;
+                    succeeded = false;
                     break;
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"Vector256.Create(SByte): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"   value: ({string.Join(", ", expectedValues)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", resultElements)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/General/Vector256/CreateElement.Single.cs b/tests/src/JIT/HardwareIntrinsics/General/Vector256/CreateElement.Single.cs
index 7f1e75dbd691..edcc76e417d2 100644
--- a/tests/src/JIT/HardwareIntrinsics/General/Vector256/CreateElement.Single.cs
+++ b/tests/src/JIT/HardwareIntrinsics/General/Vector256/CreateElement.Single.cs
@@ -88,21 +88,25 @@ private void ValidateResult(Vector256<Single> result, Single[] expectedValues, [
 
         private void ValidateResult(Single[] resultElements, Single[] expectedValues, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             for (var i = 0; i < ElementCount; i++)
             {
                 if (resultElements[i] != expectedValues[i])
                 {
-                    Succeeded = false;
+                    succeeded = false;
                     break;
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"Vector256.Create(Single): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"   value: ({string.Join(", ", expectedValues)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", resultElements)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/General/Vector256/CreateElement.UInt16.cs b/tests/src/JIT/HardwareIntrinsics/General/Vector256/CreateElement.UInt16.cs
index dde57f1b2901..10c7ca2154cf 100644
--- a/tests/src/JIT/HardwareIntrinsics/General/Vector256/CreateElement.UInt16.cs
+++ b/tests/src/JIT/HardwareIntrinsics/General/Vector256/CreateElement.UInt16.cs
@@ -88,21 +88,25 @@ private void ValidateResult(Vector256<UInt16> result, UInt16[] expectedValues, [
 
         private void ValidateResult(UInt16[] resultElements, UInt16[] expectedValues, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             for (var i = 0; i < ElementCount; i++)
             {
                 if (resultElements[i] != expectedValues[i])
                 {
-                    Succeeded = false;
+                    succeeded = false;
                     break;
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"Vector256.Create(UInt16): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"   value: ({string.Join(", ", expectedValues)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", resultElements)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/General/Vector256/CreateElement.UInt32.cs b/tests/src/JIT/HardwareIntrinsics/General/Vector256/CreateElement.UInt32.cs
index d10f7b72d53f..18e761663c96 100644
--- a/tests/src/JIT/HardwareIntrinsics/General/Vector256/CreateElement.UInt32.cs
+++ b/tests/src/JIT/HardwareIntrinsics/General/Vector256/CreateElement.UInt32.cs
@@ -88,21 +88,25 @@ private void ValidateResult(Vector256<UInt32> result, UInt32[] expectedValues, [
 
         private void ValidateResult(UInt32[] resultElements, UInt32[] expectedValues, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             for (var i = 0; i < ElementCount; i++)
             {
                 if (resultElements[i] != expectedValues[i])
                 {
-                    Succeeded = false;
+                    succeeded = false;
                     break;
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"Vector256.Create(UInt32): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"   value: ({string.Join(", ", expectedValues)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", resultElements)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/General/Vector256/CreateElement.UInt64.cs b/tests/src/JIT/HardwareIntrinsics/General/Vector256/CreateElement.UInt64.cs
index 741f10e123c4..a15447b4e3fc 100644
--- a/tests/src/JIT/HardwareIntrinsics/General/Vector256/CreateElement.UInt64.cs
+++ b/tests/src/JIT/HardwareIntrinsics/General/Vector256/CreateElement.UInt64.cs
@@ -88,21 +88,25 @@ private void ValidateResult(Vector256<UInt64> result, UInt64[] expectedValues, [
 
         private void ValidateResult(UInt64[] resultElements, UInt64[] expectedValues, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             for (var i = 0; i < ElementCount; i++)
             {
                 if (resultElements[i] != expectedValues[i])
                 {
-                    Succeeded = false;
+                    succeeded = false;
                     break;
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"Vector256.Create(UInt64): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"   value: ({string.Join(", ", expectedValues)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", resultElements)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/General/Vector256/CreateScalar.Byte.cs b/tests/src/JIT/HardwareIntrinsics/General/Vector256/CreateScalar.Byte.cs
index a01b2f830c64..c2edd4b747cd 100644
--- a/tests/src/JIT/HardwareIntrinsics/General/Vector256/CreateScalar.Byte.cs
+++ b/tests/src/JIT/HardwareIntrinsics/General/Vector256/CreateScalar.Byte.cs
@@ -74,9 +74,11 @@ private void ValidateResult(Vector256<Byte> result, Byte expectedValue, [CallerM
 
         private void ValidateResult(Byte[] resultElements, Byte expectedValue, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (resultElements[0] != expectedValue)
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -84,18 +86,20 @@ private void ValidateResult(Byte[] resultElements, Byte expectedValue, [CallerMe
                 {
                     if (resultElements[i] != 0)
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"Vector256.CreateScalar(Byte): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"   value: {expectedValue}");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", resultElements)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/General/Vector256/CreateScalar.Double.cs b/tests/src/JIT/HardwareIntrinsics/General/Vector256/CreateScalar.Double.cs
index 8e436125d477..d1d4ebb71ab3 100644
--- a/tests/src/JIT/HardwareIntrinsics/General/Vector256/CreateScalar.Double.cs
+++ b/tests/src/JIT/HardwareIntrinsics/General/Vector256/CreateScalar.Double.cs
@@ -74,9 +74,11 @@ private void ValidateResult(Vector256<Double> result, Double expectedValue, [Cal
 
         private void ValidateResult(Double[] resultElements, Double expectedValue, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (resultElements[0] != expectedValue)
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -84,18 +86,20 @@ private void ValidateResult(Double[] resultElements, Double expectedValue, [Call
                 {
                     if (resultElements[i] != 0)
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"Vector256.CreateScalar(Double): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"   value: {expectedValue}");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", resultElements)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/General/Vector256/CreateScalar.Int16.cs b/tests/src/JIT/HardwareIntrinsics/General/Vector256/CreateScalar.Int16.cs
index b0c521a077d6..8823769302b6 100644
--- a/tests/src/JIT/HardwareIntrinsics/General/Vector256/CreateScalar.Int16.cs
+++ b/tests/src/JIT/HardwareIntrinsics/General/Vector256/CreateScalar.Int16.cs
@@ -74,9 +74,11 @@ private void ValidateResult(Vector256<Int16> result, Int16 expectedValue, [Calle
 
         private void ValidateResult(Int16[] resultElements, Int16 expectedValue, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (resultElements[0] != expectedValue)
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -84,18 +86,20 @@ private void ValidateResult(Int16[] resultElements, Int16 expectedValue, [Caller
                 {
                     if (resultElements[i] != 0)
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"Vector256.CreateScalar(Int16): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"   value: {expectedValue}");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", resultElements)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/General/Vector256/CreateScalar.Int32.cs b/tests/src/JIT/HardwareIntrinsics/General/Vector256/CreateScalar.Int32.cs
index 4f17d3833d90..6459a66d4795 100644
--- a/tests/src/JIT/HardwareIntrinsics/General/Vector256/CreateScalar.Int32.cs
+++ b/tests/src/JIT/HardwareIntrinsics/General/Vector256/CreateScalar.Int32.cs
@@ -74,9 +74,11 @@ private void ValidateResult(Vector256<Int32> result, Int32 expectedValue, [Calle
 
         private void ValidateResult(Int32[] resultElements, Int32 expectedValue, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (resultElements[0] != expectedValue)
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -84,18 +86,20 @@ private void ValidateResult(Int32[] resultElements, Int32 expectedValue, [Caller
                 {
                     if (resultElements[i] != 0)
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"Vector256.CreateScalar(Int32): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"   value: {expectedValue}");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", resultElements)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/General/Vector256/CreateScalar.Int64.cs b/tests/src/JIT/HardwareIntrinsics/General/Vector256/CreateScalar.Int64.cs
index 7ffa367a4ec8..997d43666347 100644
--- a/tests/src/JIT/HardwareIntrinsics/General/Vector256/CreateScalar.Int64.cs
+++ b/tests/src/JIT/HardwareIntrinsics/General/Vector256/CreateScalar.Int64.cs
@@ -74,9 +74,11 @@ private void ValidateResult(Vector256<Int64> result, Int64 expectedValue, [Calle
 
         private void ValidateResult(Int64[] resultElements, Int64 expectedValue, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (resultElements[0] != expectedValue)
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -84,18 +86,20 @@ private void ValidateResult(Int64[] resultElements, Int64 expectedValue, [Caller
                 {
                     if (resultElements[i] != 0)
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"Vector256.CreateScalar(Int64): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"   value: {expectedValue}");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", resultElements)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/General/Vector256/CreateScalar.SByte.cs b/tests/src/JIT/HardwareIntrinsics/General/Vector256/CreateScalar.SByte.cs
index 5a287d0895ad..2270b471da76 100644
--- a/tests/src/JIT/HardwareIntrinsics/General/Vector256/CreateScalar.SByte.cs
+++ b/tests/src/JIT/HardwareIntrinsics/General/Vector256/CreateScalar.SByte.cs
@@ -74,9 +74,11 @@ private void ValidateResult(Vector256<SByte> result, SByte expectedValue, [Calle
 
         private void ValidateResult(SByte[] resultElements, SByte expectedValue, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (resultElements[0] != expectedValue)
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -84,18 +86,20 @@ private void ValidateResult(SByte[] resultElements, SByte expectedValue, [Caller
                 {
                     if (resultElements[i] != 0)
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"Vector256.CreateScalar(SByte): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"   value: {expectedValue}");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", resultElements)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/General/Vector256/CreateScalar.Single.cs b/tests/src/JIT/HardwareIntrinsics/General/Vector256/CreateScalar.Single.cs
index d630661158d8..5b652253ef74 100644
--- a/tests/src/JIT/HardwareIntrinsics/General/Vector256/CreateScalar.Single.cs
+++ b/tests/src/JIT/HardwareIntrinsics/General/Vector256/CreateScalar.Single.cs
@@ -74,9 +74,11 @@ private void ValidateResult(Vector256<Single> result, Single expectedValue, [Cal
 
         private void ValidateResult(Single[] resultElements, Single expectedValue, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (resultElements[0] != expectedValue)
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -84,18 +86,20 @@ private void ValidateResult(Single[] resultElements, Single expectedValue, [Call
                 {
                     if (resultElements[i] != 0)
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"Vector256.CreateScalar(Single): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"   value: {expectedValue}");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", resultElements)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/General/Vector256/CreateScalar.UInt16.cs b/tests/src/JIT/HardwareIntrinsics/General/Vector256/CreateScalar.UInt16.cs
index 266123d4f1c3..970e0a826fad 100644
--- a/tests/src/JIT/HardwareIntrinsics/General/Vector256/CreateScalar.UInt16.cs
+++ b/tests/src/JIT/HardwareIntrinsics/General/Vector256/CreateScalar.UInt16.cs
@@ -74,9 +74,11 @@ private void ValidateResult(Vector256<UInt16> result, UInt16 expectedValue, [Cal
 
         private void ValidateResult(UInt16[] resultElements, UInt16 expectedValue, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (resultElements[0] != expectedValue)
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -84,18 +86,20 @@ private void ValidateResult(UInt16[] resultElements, UInt16 expectedValue, [Call
                 {
                     if (resultElements[i] != 0)
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"Vector256.CreateScalar(UInt16): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"   value: {expectedValue}");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", resultElements)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/General/Vector256/CreateScalar.UInt32.cs b/tests/src/JIT/HardwareIntrinsics/General/Vector256/CreateScalar.UInt32.cs
index f4ba583b4807..65513023fedc 100644
--- a/tests/src/JIT/HardwareIntrinsics/General/Vector256/CreateScalar.UInt32.cs
+++ b/tests/src/JIT/HardwareIntrinsics/General/Vector256/CreateScalar.UInt32.cs
@@ -74,9 +74,11 @@ private void ValidateResult(Vector256<UInt32> result, UInt32 expectedValue, [Cal
 
         private void ValidateResult(UInt32[] resultElements, UInt32 expectedValue, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (resultElements[0] != expectedValue)
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -84,18 +86,20 @@ private void ValidateResult(UInt32[] resultElements, UInt32 expectedValue, [Call
                 {
                     if (resultElements[i] != 0)
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"Vector256.CreateScalar(UInt32): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"   value: {expectedValue}");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", resultElements)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/General/Vector256/CreateScalar.UInt64.cs b/tests/src/JIT/HardwareIntrinsics/General/Vector256/CreateScalar.UInt64.cs
index ea4c586c821c..4a9a55fc9821 100644
--- a/tests/src/JIT/HardwareIntrinsics/General/Vector256/CreateScalar.UInt64.cs
+++ b/tests/src/JIT/HardwareIntrinsics/General/Vector256/CreateScalar.UInt64.cs
@@ -74,9 +74,11 @@ private void ValidateResult(Vector256<UInt64> result, UInt64 expectedValue, [Cal
 
         private void ValidateResult(UInt64[] resultElements, UInt64 expectedValue, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (resultElements[0] != expectedValue)
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -84,18 +86,20 @@ private void ValidateResult(UInt64[] resultElements, UInt64 expectedValue, [Call
                 {
                     if (resultElements[i] != 0)
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"Vector256.CreateScalar(UInt64): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"   value: {expectedValue}");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", resultElements)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/General/Vector256/CreateScalarUnsafe.Byte.cs b/tests/src/JIT/HardwareIntrinsics/General/Vector256/CreateScalarUnsafe.Byte.cs
index 8c58813f58d4..ae4e45210a4c 100644
--- a/tests/src/JIT/HardwareIntrinsics/General/Vector256/CreateScalarUnsafe.Byte.cs
+++ b/tests/src/JIT/HardwareIntrinsics/General/Vector256/CreateScalarUnsafe.Byte.cs
@@ -74,9 +74,11 @@ private void ValidateResult(Vector256<Byte> result, Byte expectedValue, [CallerM
 
         private void ValidateResult(Byte[] resultElements, Byte expectedValue, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (resultElements[0] != expectedValue)
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -84,18 +86,20 @@ private void ValidateResult(Byte[] resultElements, Byte expectedValue, [CallerMe
                 {
                     if (false /* value is uninitialized */)
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"Vector256.CreateScalarUnsafe(Byte): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"   value: {expectedValue}");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", resultElements)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/General/Vector256/CreateScalarUnsafe.Double.cs b/tests/src/JIT/HardwareIntrinsics/General/Vector256/CreateScalarUnsafe.Double.cs
index 6ec1707062a8..9407ef19c50a 100644
--- a/tests/src/JIT/HardwareIntrinsics/General/Vector256/CreateScalarUnsafe.Double.cs
+++ b/tests/src/JIT/HardwareIntrinsics/General/Vector256/CreateScalarUnsafe.Double.cs
@@ -74,9 +74,11 @@ private void ValidateResult(Vector256<Double> result, Double expectedValue, [Cal
 
         private void ValidateResult(Double[] resultElements, Double expectedValue, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (resultElements[0] != expectedValue)
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -84,18 +86,20 @@ private void ValidateResult(Double[] resultElements, Double expectedValue, [Call
                 {
                     if (false /* value is uninitialized */)
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"Vector256.CreateScalarUnsafe(Double): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"   value: {expectedValue}");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", resultElements)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/General/Vector256/CreateScalarUnsafe.Int16.cs b/tests/src/JIT/HardwareIntrinsics/General/Vector256/CreateScalarUnsafe.Int16.cs
index 98f4bda7c24f..d21277257aab 100644
--- a/tests/src/JIT/HardwareIntrinsics/General/Vector256/CreateScalarUnsafe.Int16.cs
+++ b/tests/src/JIT/HardwareIntrinsics/General/Vector256/CreateScalarUnsafe.Int16.cs
@@ -74,9 +74,11 @@ private void ValidateResult(Vector256<Int16> result, Int16 expectedValue, [Calle
 
         private void ValidateResult(Int16[] resultElements, Int16 expectedValue, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (resultElements[0] != expectedValue)
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -84,18 +86,20 @@ private void ValidateResult(Int16[] resultElements, Int16 expectedValue, [Caller
                 {
                     if (false /* value is uninitialized */)
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"Vector256.CreateScalarUnsafe(Int16): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"   value: {expectedValue}");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", resultElements)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/General/Vector256/CreateScalarUnsafe.Int32.cs b/tests/src/JIT/HardwareIntrinsics/General/Vector256/CreateScalarUnsafe.Int32.cs
index 9d26ae5be268..b49df4ce776e 100644
--- a/tests/src/JIT/HardwareIntrinsics/General/Vector256/CreateScalarUnsafe.Int32.cs
+++ b/tests/src/JIT/HardwareIntrinsics/General/Vector256/CreateScalarUnsafe.Int32.cs
@@ -74,9 +74,11 @@ private void ValidateResult(Vector256<Int32> result, Int32 expectedValue, [Calle
 
         private void ValidateResult(Int32[] resultElements, Int32 expectedValue, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (resultElements[0] != expectedValue)
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -84,18 +86,20 @@ private void ValidateResult(Int32[] resultElements, Int32 expectedValue, [Caller
                 {
                     if (false /* value is uninitialized */)
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"Vector256.CreateScalarUnsafe(Int32): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"   value: {expectedValue}");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", resultElements)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/General/Vector256/CreateScalarUnsafe.Int64.cs b/tests/src/JIT/HardwareIntrinsics/General/Vector256/CreateScalarUnsafe.Int64.cs
index c64e57d45b3c..ebd592f4bf2f 100644
--- a/tests/src/JIT/HardwareIntrinsics/General/Vector256/CreateScalarUnsafe.Int64.cs
+++ b/tests/src/JIT/HardwareIntrinsics/General/Vector256/CreateScalarUnsafe.Int64.cs
@@ -74,9 +74,11 @@ private void ValidateResult(Vector256<Int64> result, Int64 expectedValue, [Calle
 
         private void ValidateResult(Int64[] resultElements, Int64 expectedValue, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (resultElements[0] != expectedValue)
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -84,18 +86,20 @@ private void ValidateResult(Int64[] resultElements, Int64 expectedValue, [Caller
                 {
                     if (false /* value is uninitialized */)
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"Vector256.CreateScalarUnsafe(Int64): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"   value: {expectedValue}");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", resultElements)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/General/Vector256/CreateScalarUnsafe.SByte.cs b/tests/src/JIT/HardwareIntrinsics/General/Vector256/CreateScalarUnsafe.SByte.cs
index 20109ada1d4c..6bc98c13dd3f 100644
--- a/tests/src/JIT/HardwareIntrinsics/General/Vector256/CreateScalarUnsafe.SByte.cs
+++ b/tests/src/JIT/HardwareIntrinsics/General/Vector256/CreateScalarUnsafe.SByte.cs
@@ -74,9 +74,11 @@ private void ValidateResult(Vector256<SByte> result, SByte expectedValue, [Calle
 
         private void ValidateResult(SByte[] resultElements, SByte expectedValue, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (resultElements[0] != expectedValue)
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -84,18 +86,20 @@ private void ValidateResult(SByte[] resultElements, SByte expectedValue, [Caller
                 {
                     if (false /* value is uninitialized */)
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"Vector256.CreateScalarUnsafe(SByte): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"   value: {expectedValue}");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", resultElements)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/General/Vector256/CreateScalarUnsafe.Single.cs b/tests/src/JIT/HardwareIntrinsics/General/Vector256/CreateScalarUnsafe.Single.cs
index 62468e6bc0fc..23acf5701512 100644
--- a/tests/src/JIT/HardwareIntrinsics/General/Vector256/CreateScalarUnsafe.Single.cs
+++ b/tests/src/JIT/HardwareIntrinsics/General/Vector256/CreateScalarUnsafe.Single.cs
@@ -74,9 +74,11 @@ private void ValidateResult(Vector256<Single> result, Single expectedValue, [Cal
 
         private void ValidateResult(Single[] resultElements, Single expectedValue, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (resultElements[0] != expectedValue)
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -84,18 +86,20 @@ private void ValidateResult(Single[] resultElements, Single expectedValue, [Call
                 {
                     if (false /* value is uninitialized */)
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"Vector256.CreateScalarUnsafe(Single): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"   value: {expectedValue}");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", resultElements)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/General/Vector256/CreateScalarUnsafe.UInt16.cs b/tests/src/JIT/HardwareIntrinsics/General/Vector256/CreateScalarUnsafe.UInt16.cs
index 4d8ce6002715..79da9166bae5 100644
--- a/tests/src/JIT/HardwareIntrinsics/General/Vector256/CreateScalarUnsafe.UInt16.cs
+++ b/tests/src/JIT/HardwareIntrinsics/General/Vector256/CreateScalarUnsafe.UInt16.cs
@@ -74,9 +74,11 @@ private void ValidateResult(Vector256<UInt16> result, UInt16 expectedValue, [Cal
 
         private void ValidateResult(UInt16[] resultElements, UInt16 expectedValue, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (resultElements[0] != expectedValue)
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -84,18 +86,20 @@ private void ValidateResult(UInt16[] resultElements, UInt16 expectedValue, [Call
                 {
                     if (false /* value is uninitialized */)
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"Vector256.CreateScalarUnsafe(UInt16): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"   value: {expectedValue}");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", resultElements)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/General/Vector256/CreateScalarUnsafe.UInt32.cs b/tests/src/JIT/HardwareIntrinsics/General/Vector256/CreateScalarUnsafe.UInt32.cs
index 7470a64093d5..5fef3b92301e 100644
--- a/tests/src/JIT/HardwareIntrinsics/General/Vector256/CreateScalarUnsafe.UInt32.cs
+++ b/tests/src/JIT/HardwareIntrinsics/General/Vector256/CreateScalarUnsafe.UInt32.cs
@@ -74,9 +74,11 @@ private void ValidateResult(Vector256<UInt32> result, UInt32 expectedValue, [Cal
 
         private void ValidateResult(UInt32[] resultElements, UInt32 expectedValue, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (resultElements[0] != expectedValue)
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -84,18 +86,20 @@ private void ValidateResult(UInt32[] resultElements, UInt32 expectedValue, [Call
                 {
                     if (false /* value is uninitialized */)
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"Vector256.CreateScalarUnsafe(UInt32): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"   value: {expectedValue}");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", resultElements)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/General/Vector256/CreateScalarUnsafe.UInt64.cs b/tests/src/JIT/HardwareIntrinsics/General/Vector256/CreateScalarUnsafe.UInt64.cs
index 631476cd640e..67a62ab6c881 100644
--- a/tests/src/JIT/HardwareIntrinsics/General/Vector256/CreateScalarUnsafe.UInt64.cs
+++ b/tests/src/JIT/HardwareIntrinsics/General/Vector256/CreateScalarUnsafe.UInt64.cs
@@ -74,9 +74,11 @@ private void ValidateResult(Vector256<UInt64> result, UInt64 expectedValue, [Cal
 
         private void ValidateResult(UInt64[] resultElements, UInt64 expectedValue, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (resultElements[0] != expectedValue)
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -84,18 +86,20 @@ private void ValidateResult(UInt64[] resultElements, UInt64 expectedValue, [Call
                 {
                     if (false /* value is uninitialized */)
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"Vector256.CreateScalarUnsafe(UInt64): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"   value: {expectedValue}");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", resultElements)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/General/Vector256/CreateVector.Byte.cs b/tests/src/JIT/HardwareIntrinsics/General/Vector256/CreateVector.Byte.cs
index a7b8c76c3c9f..04066c5b2c7b 100644
--- a/tests/src/JIT/HardwareIntrinsics/General/Vector256/CreateVector.Byte.cs
+++ b/tests/src/JIT/HardwareIntrinsics/General/Vector256/CreateVector.Byte.cs
@@ -84,11 +84,13 @@ private void ValidateResult(Vector256<Byte> result, Byte expectedLowerValue, Byt
 
         private void ValidateResult(Byte[] resultElements, Byte expectedLowerValue, Byte expectedUpperValue, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             for (var i = 0; i < ElementCount / 2; i++)
             {
                 if (resultElements[i] != expectedLowerValue)
                 {
-                    Succeeded = false;
+                    succeeded = false;
                     break;
                 }
             }
@@ -97,18 +99,20 @@ private void ValidateResult(Byte[] resultElements, Byte expectedLowerValue, Byte
             {
                 if (resultElements[i] != expectedUpperValue)
                 {
-                    Succeeded = false;
+                    succeeded = false;
                     break;
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"Vector256.Create(Byte): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"   lower: {expectedLowerValue}");
                 TestLibrary.TestFramework.LogInformation($"   upper: {expectedUpperValue}");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", resultElements)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/General/Vector256/CreateVector.Double.cs b/tests/src/JIT/HardwareIntrinsics/General/Vector256/CreateVector.Double.cs
index 59b545172882..4f75b5a6c356 100644
--- a/tests/src/JIT/HardwareIntrinsics/General/Vector256/CreateVector.Double.cs
+++ b/tests/src/JIT/HardwareIntrinsics/General/Vector256/CreateVector.Double.cs
@@ -84,11 +84,13 @@ private void ValidateResult(Vector256<Double> result, Double expectedLowerValue,
 
         private void ValidateResult(Double[] resultElements, Double expectedLowerValue, Double expectedUpperValue, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             for (var i = 0; i < ElementCount / 2; i++)
             {
                 if (resultElements[i] != expectedLowerValue)
                 {
-                    Succeeded = false;
+                    succeeded = false;
                     break;
                 }
             }
@@ -97,18 +99,20 @@ private void ValidateResult(Double[] resultElements, Double expectedLowerValue,
             {
                 if (resultElements[i] != expectedUpperValue)
                 {
-                    Succeeded = false;
+                    succeeded = false;
                     break;
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"Vector256.Create(Double): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"   lower: {expectedLowerValue}");
                 TestLibrary.TestFramework.LogInformation($"   upper: {expectedUpperValue}");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", resultElements)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/General/Vector256/CreateVector.Int16.cs b/tests/src/JIT/HardwareIntrinsics/General/Vector256/CreateVector.Int16.cs
index fd1e89dfcef4..08f30d2aee34 100644
--- a/tests/src/JIT/HardwareIntrinsics/General/Vector256/CreateVector.Int16.cs
+++ b/tests/src/JIT/HardwareIntrinsics/General/Vector256/CreateVector.Int16.cs
@@ -84,11 +84,13 @@ private void ValidateResult(Vector256<Int16> result, Int16 expectedLowerValue, I
 
         private void ValidateResult(Int16[] resultElements, Int16 expectedLowerValue, Int16 expectedUpperValue, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             for (var i = 0; i < ElementCount / 2; i++)
             {
                 if (resultElements[i] != expectedLowerValue)
                 {
-                    Succeeded = false;
+                    succeeded = false;
                     break;
                 }
             }
@@ -97,18 +99,20 @@ private void ValidateResult(Int16[] resultElements, Int16 expectedLowerValue, In
             {
                 if (resultElements[i] != expectedUpperValue)
                 {
-                    Succeeded = false;
+                    succeeded = false;
                     break;
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"Vector256.Create(Int16): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"   lower: {expectedLowerValue}");
                 TestLibrary.TestFramework.LogInformation($"   upper: {expectedUpperValue}");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", resultElements)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/General/Vector256/CreateVector.Int32.cs b/tests/src/JIT/HardwareIntrinsics/General/Vector256/CreateVector.Int32.cs
index bd2628143b83..e0128f82ed5e 100644
--- a/tests/src/JIT/HardwareIntrinsics/General/Vector256/CreateVector.Int32.cs
+++ b/tests/src/JIT/HardwareIntrinsics/General/Vector256/CreateVector.Int32.cs
@@ -84,11 +84,13 @@ private void ValidateResult(Vector256<Int32> result, Int32 expectedLowerValue, I
 
         private void ValidateResult(Int32[] resultElements, Int32 expectedLowerValue, Int32 expectedUpperValue, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             for (var i = 0; i < ElementCount / 2; i++)
             {
                 if (resultElements[i] != expectedLowerValue)
                 {
-                    Succeeded = false;
+                    succeeded = false;
                     break;
                 }
             }
@@ -97,18 +99,20 @@ private void ValidateResult(Int32[] resultElements, Int32 expectedLowerValue, In
             {
                 if (resultElements[i] != expectedUpperValue)
                 {
-                    Succeeded = false;
+                    succeeded = false;
                     break;
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"Vector256.Create(Int32): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"   lower: {expectedLowerValue}");
                 TestLibrary.TestFramework.LogInformation($"   upper: {expectedUpperValue}");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", resultElements)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/General/Vector256/CreateVector.Int64.cs b/tests/src/JIT/HardwareIntrinsics/General/Vector256/CreateVector.Int64.cs
index 2718a8f6d544..e312218370a3 100644
--- a/tests/src/JIT/HardwareIntrinsics/General/Vector256/CreateVector.Int64.cs
+++ b/tests/src/JIT/HardwareIntrinsics/General/Vector256/CreateVector.Int64.cs
@@ -84,11 +84,13 @@ private void ValidateResult(Vector256<Int64> result, Int64 expectedLowerValue, I
 
         private void ValidateResult(Int64[] resultElements, Int64 expectedLowerValue, Int64 expectedUpperValue, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             for (var i = 0; i < ElementCount / 2; i++)
             {
                 if (resultElements[i] != expectedLowerValue)
                 {
-                    Succeeded = false;
+                    succeeded = false;
                     break;
                 }
             }
@@ -97,18 +99,20 @@ private void ValidateResult(Int64[] resultElements, Int64 expectedLowerValue, In
             {
                 if (resultElements[i] != expectedUpperValue)
                 {
-                    Succeeded = false;
+                    succeeded = false;
                     break;
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"Vector256.Create(Int64): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"   lower: {expectedLowerValue}");
                 TestLibrary.TestFramework.LogInformation($"   upper: {expectedUpperValue}");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", resultElements)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/General/Vector256/CreateVector.SByte.cs b/tests/src/JIT/HardwareIntrinsics/General/Vector256/CreateVector.SByte.cs
index 9d5778a617fd..13c1b974d592 100644
--- a/tests/src/JIT/HardwareIntrinsics/General/Vector256/CreateVector.SByte.cs
+++ b/tests/src/JIT/HardwareIntrinsics/General/Vector256/CreateVector.SByte.cs
@@ -84,11 +84,13 @@ private void ValidateResult(Vector256<SByte> result, SByte expectedLowerValue, S
 
         private void ValidateResult(SByte[] resultElements, SByte expectedLowerValue, SByte expectedUpperValue, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             for (var i = 0; i < ElementCount / 2; i++)
             {
                 if (resultElements[i] != expectedLowerValue)
                 {
-                    Succeeded = false;
+                    succeeded = false;
                     break;
                 }
             }
@@ -97,18 +99,20 @@ private void ValidateResult(SByte[] resultElements, SByte expectedLowerValue, SB
             {
                 if (resultElements[i] != expectedUpperValue)
                 {
-                    Succeeded = false;
+                    succeeded = false;
                     break;
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"Vector256.Create(SByte): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"   lower: {expectedLowerValue}");
                 TestLibrary.TestFramework.LogInformation($"   upper: {expectedUpperValue}");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", resultElements)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/General/Vector256/CreateVector.Single.cs b/tests/src/JIT/HardwareIntrinsics/General/Vector256/CreateVector.Single.cs
index 67ac16a8cb83..fd350e157e4f 100644
--- a/tests/src/JIT/HardwareIntrinsics/General/Vector256/CreateVector.Single.cs
+++ b/tests/src/JIT/HardwareIntrinsics/General/Vector256/CreateVector.Single.cs
@@ -84,11 +84,13 @@ private void ValidateResult(Vector256<Single> result, Single expectedLowerValue,
 
         private void ValidateResult(Single[] resultElements, Single expectedLowerValue, Single expectedUpperValue, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             for (var i = 0; i < ElementCount / 2; i++)
             {
                 if (resultElements[i] != expectedLowerValue)
                 {
-                    Succeeded = false;
+                    succeeded = false;
                     break;
                 }
             }
@@ -97,18 +99,20 @@ private void ValidateResult(Single[] resultElements, Single expectedLowerValue,
             {
                 if (resultElements[i] != expectedUpperValue)
                 {
-                    Succeeded = false;
+                    succeeded = false;
                     break;
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"Vector256.Create(Single): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"   lower: {expectedLowerValue}");
                 TestLibrary.TestFramework.LogInformation($"   upper: {expectedUpperValue}");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", resultElements)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/General/Vector256/CreateVector.UInt16.cs b/tests/src/JIT/HardwareIntrinsics/General/Vector256/CreateVector.UInt16.cs
index 65c53f79c4de..823fb235fee3 100644
--- a/tests/src/JIT/HardwareIntrinsics/General/Vector256/CreateVector.UInt16.cs
+++ b/tests/src/JIT/HardwareIntrinsics/General/Vector256/CreateVector.UInt16.cs
@@ -84,11 +84,13 @@ private void ValidateResult(Vector256<UInt16> result, UInt16 expectedLowerValue,
 
         private void ValidateResult(UInt16[] resultElements, UInt16 expectedLowerValue, UInt16 expectedUpperValue, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             for (var i = 0; i < ElementCount / 2; i++)
             {
                 if (resultElements[i] != expectedLowerValue)
                 {
-                    Succeeded = false;
+                    succeeded = false;
                     break;
                 }
             }
@@ -97,18 +99,20 @@ private void ValidateResult(UInt16[] resultElements, UInt16 expectedLowerValue,
             {
                 if (resultElements[i] != expectedUpperValue)
                 {
-                    Succeeded = false;
+                    succeeded = false;
                     break;
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"Vector256.Create(UInt16): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"   lower: {expectedLowerValue}");
                 TestLibrary.TestFramework.LogInformation($"   upper: {expectedUpperValue}");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", resultElements)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/General/Vector256/CreateVector.UInt32.cs b/tests/src/JIT/HardwareIntrinsics/General/Vector256/CreateVector.UInt32.cs
index 8be70914fbb5..6c4dac3c9831 100644
--- a/tests/src/JIT/HardwareIntrinsics/General/Vector256/CreateVector.UInt32.cs
+++ b/tests/src/JIT/HardwareIntrinsics/General/Vector256/CreateVector.UInt32.cs
@@ -84,11 +84,13 @@ private void ValidateResult(Vector256<UInt32> result, UInt32 expectedLowerValue,
 
         private void ValidateResult(UInt32[] resultElements, UInt32 expectedLowerValue, UInt32 expectedUpperValue, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             for (var i = 0; i < ElementCount / 2; i++)
             {
                 if (resultElements[i] != expectedLowerValue)
                 {
-                    Succeeded = false;
+                    succeeded = false;
                     break;
                 }
             }
@@ -97,18 +99,20 @@ private void ValidateResult(UInt32[] resultElements, UInt32 expectedLowerValue,
             {
                 if (resultElements[i] != expectedUpperValue)
                 {
-                    Succeeded = false;
+                    succeeded = false;
                     break;
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"Vector256.Create(UInt32): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"   lower: {expectedLowerValue}");
                 TestLibrary.TestFramework.LogInformation($"   upper: {expectedUpperValue}");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", resultElements)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/General/Vector256/CreateVector.UInt64.cs b/tests/src/JIT/HardwareIntrinsics/General/Vector256/CreateVector.UInt64.cs
index ba5dd720788c..c46fc300ef07 100644
--- a/tests/src/JIT/HardwareIntrinsics/General/Vector256/CreateVector.UInt64.cs
+++ b/tests/src/JIT/HardwareIntrinsics/General/Vector256/CreateVector.UInt64.cs
@@ -84,11 +84,13 @@ private void ValidateResult(Vector256<UInt64> result, UInt64 expectedLowerValue,
 
         private void ValidateResult(UInt64[] resultElements, UInt64 expectedLowerValue, UInt64 expectedUpperValue, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             for (var i = 0; i < ElementCount / 2; i++)
             {
                 if (resultElements[i] != expectedLowerValue)
                 {
-                    Succeeded = false;
+                    succeeded = false;
                     break;
                 }
             }
@@ -97,18 +99,20 @@ private void ValidateResult(UInt64[] resultElements, UInt64 expectedLowerValue,
             {
                 if (resultElements[i] != expectedUpperValue)
                 {
-                    Succeeded = false;
+                    succeeded = false;
                     break;
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"Vector256.Create(UInt64): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"   lower: {expectedLowerValue}");
                 TestLibrary.TestFramework.LogInformation($"   upper: {expectedUpperValue}");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", resultElements)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/General/Vector256_1/As.Byte.cs b/tests/src/JIT/HardwareIntrinsics/General/Vector256_1/As.Byte.cs
index 40355d565574..aaa9fa638caf 100644
--- a/tests/src/JIT/HardwareIntrinsics/General/Vector256_1/As.Byte.cs
+++ b/tests/src/JIT/HardwareIntrinsics/General/Vector256_1/As.Byte.cs
@@ -218,21 +218,25 @@ private void ValidateResult<T>(Vector256<T> result, Vector256<Byte> value, [Call
 
         private void ValidateResult(Byte[] resultElements, Byte[] valueElements, Type targetType, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             for (var i = 0; i < ElementCount; i++)
             {
                 if (resultElements[i] != valueElements[i])
                 {
-                    Succeeded = false;
+                    succeeded = false;
                     break;
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"Vector256<Byte>.As{targetType.Name}: {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"   value: ({string.Join(", ", valueElements)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", resultElements)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/General/Vector256_1/As.Double.cs b/tests/src/JIT/HardwareIntrinsics/General/Vector256_1/As.Double.cs
index c68a344bee19..f2a2d73ec414 100644
--- a/tests/src/JIT/HardwareIntrinsics/General/Vector256_1/As.Double.cs
+++ b/tests/src/JIT/HardwareIntrinsics/General/Vector256_1/As.Double.cs
@@ -218,21 +218,25 @@ private void ValidateResult<T>(Vector256<T> result, Vector256<Double> value, [Ca
 
         private void ValidateResult(Double[] resultElements, Double[] valueElements, Type targetType, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             for (var i = 0; i < ElementCount; i++)
             {
                 if (resultElements[i] != valueElements[i])
                 {
-                    Succeeded = false;
+                    succeeded = false;
                     break;
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"Vector256<Double>.As{targetType.Name}: {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"   value: ({string.Join(", ", valueElements)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", resultElements)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/General/Vector256_1/As.Int16.cs b/tests/src/JIT/HardwareIntrinsics/General/Vector256_1/As.Int16.cs
index 4e5cb76714f6..11020a52b7c1 100644
--- a/tests/src/JIT/HardwareIntrinsics/General/Vector256_1/As.Int16.cs
+++ b/tests/src/JIT/HardwareIntrinsics/General/Vector256_1/As.Int16.cs
@@ -218,21 +218,25 @@ private void ValidateResult<T>(Vector256<T> result, Vector256<Int16> value, [Cal
 
         private void ValidateResult(Int16[] resultElements, Int16[] valueElements, Type targetType, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             for (var i = 0; i < ElementCount; i++)
             {
                 if (resultElements[i] != valueElements[i])
                 {
-                    Succeeded = false;
+                    succeeded = false;
                     break;
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"Vector256<Int16>.As{targetType.Name}: {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"   value: ({string.Join(", ", valueElements)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", resultElements)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/General/Vector256_1/As.Int32.cs b/tests/src/JIT/HardwareIntrinsics/General/Vector256_1/As.Int32.cs
index a5f03b8c7592..b29874bc4c93 100644
--- a/tests/src/JIT/HardwareIntrinsics/General/Vector256_1/As.Int32.cs
+++ b/tests/src/JIT/HardwareIntrinsics/General/Vector256_1/As.Int32.cs
@@ -218,21 +218,25 @@ private void ValidateResult<T>(Vector256<T> result, Vector256<Int32> value, [Cal
 
         private void ValidateResult(Int32[] resultElements, Int32[] valueElements, Type targetType, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             for (var i = 0; i < ElementCount; i++)
             {
                 if (resultElements[i] != valueElements[i])
                 {
-                    Succeeded = false;
+                    succeeded = false;
                     break;
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"Vector256<Int32>.As{targetType.Name}: {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"   value: ({string.Join(", ", valueElements)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", resultElements)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/General/Vector256_1/As.Int64.cs b/tests/src/JIT/HardwareIntrinsics/General/Vector256_1/As.Int64.cs
index eae24b2f2c2f..3cfa62a6a9df 100644
--- a/tests/src/JIT/HardwareIntrinsics/General/Vector256_1/As.Int64.cs
+++ b/tests/src/JIT/HardwareIntrinsics/General/Vector256_1/As.Int64.cs
@@ -218,21 +218,25 @@ private void ValidateResult<T>(Vector256<T> result, Vector256<Int64> value, [Cal
 
         private void ValidateResult(Int64[] resultElements, Int64[] valueElements, Type targetType, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             for (var i = 0; i < ElementCount; i++)
             {
                 if (resultElements[i] != valueElements[i])
                 {
-                    Succeeded = false;
+                    succeeded = false;
                     break;
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"Vector256<Int64>.As{targetType.Name}: {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"   value: ({string.Join(", ", valueElements)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", resultElements)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/General/Vector256_1/As.SByte.cs b/tests/src/JIT/HardwareIntrinsics/General/Vector256_1/As.SByte.cs
index 495c07fe25f6..f6d2b7292106 100644
--- a/tests/src/JIT/HardwareIntrinsics/General/Vector256_1/As.SByte.cs
+++ b/tests/src/JIT/HardwareIntrinsics/General/Vector256_1/As.SByte.cs
@@ -218,21 +218,25 @@ private void ValidateResult<T>(Vector256<T> result, Vector256<SByte> value, [Cal
 
         private void ValidateResult(SByte[] resultElements, SByte[] valueElements, Type targetType, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             for (var i = 0; i < ElementCount; i++)
             {
                 if (resultElements[i] != valueElements[i])
                 {
-                    Succeeded = false;
+                    succeeded = false;
                     break;
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"Vector256<SByte>.As{targetType.Name}: {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"   value: ({string.Join(", ", valueElements)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", resultElements)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/General/Vector256_1/As.Single.cs b/tests/src/JIT/HardwareIntrinsics/General/Vector256_1/As.Single.cs
index 218348a12efc..206bcca23140 100644
--- a/tests/src/JIT/HardwareIntrinsics/General/Vector256_1/As.Single.cs
+++ b/tests/src/JIT/HardwareIntrinsics/General/Vector256_1/As.Single.cs
@@ -218,21 +218,25 @@ private void ValidateResult<T>(Vector256<T> result, Vector256<Single> value, [Ca
 
         private void ValidateResult(Single[] resultElements, Single[] valueElements, Type targetType, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             for (var i = 0; i < ElementCount; i++)
             {
                 if (resultElements[i] != valueElements[i])
                 {
-                    Succeeded = false;
+                    succeeded = false;
                     break;
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"Vector256<Single>.As{targetType.Name}: {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"   value: ({string.Join(", ", valueElements)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", resultElements)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/General/Vector256_1/As.UInt16.cs b/tests/src/JIT/HardwareIntrinsics/General/Vector256_1/As.UInt16.cs
index bbc844c727c5..edd0fb15f2fe 100644
--- a/tests/src/JIT/HardwareIntrinsics/General/Vector256_1/As.UInt16.cs
+++ b/tests/src/JIT/HardwareIntrinsics/General/Vector256_1/As.UInt16.cs
@@ -218,21 +218,25 @@ private void ValidateResult<T>(Vector256<T> result, Vector256<UInt16> value, [Ca
 
         private void ValidateResult(UInt16[] resultElements, UInt16[] valueElements, Type targetType, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             for (var i = 0; i < ElementCount; i++)
             {
                 if (resultElements[i] != valueElements[i])
                 {
-                    Succeeded = false;
+                    succeeded = false;
                     break;
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"Vector256<UInt16>.As{targetType.Name}: {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"   value: ({string.Join(", ", valueElements)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", resultElements)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/General/Vector256_1/As.UInt32.cs b/tests/src/JIT/HardwareIntrinsics/General/Vector256_1/As.UInt32.cs
index 15d54828f9ff..66722db57362 100644
--- a/tests/src/JIT/HardwareIntrinsics/General/Vector256_1/As.UInt32.cs
+++ b/tests/src/JIT/HardwareIntrinsics/General/Vector256_1/As.UInt32.cs
@@ -218,21 +218,25 @@ private void ValidateResult<T>(Vector256<T> result, Vector256<UInt32> value, [Ca
 
         private void ValidateResult(UInt32[] resultElements, UInt32[] valueElements, Type targetType, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             for (var i = 0; i < ElementCount; i++)
             {
                 if (resultElements[i] != valueElements[i])
                 {
-                    Succeeded = false;
+                    succeeded = false;
                     break;
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"Vector256<UInt32>.As{targetType.Name}: {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"   value: ({string.Join(", ", valueElements)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", resultElements)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/General/Vector256_1/As.UInt64.cs b/tests/src/JIT/HardwareIntrinsics/General/Vector256_1/As.UInt64.cs
index 705614b29b0d..f2ced78cd5e0 100644
--- a/tests/src/JIT/HardwareIntrinsics/General/Vector256_1/As.UInt64.cs
+++ b/tests/src/JIT/HardwareIntrinsics/General/Vector256_1/As.UInt64.cs
@@ -218,21 +218,25 @@ private void ValidateResult<T>(Vector256<T> result, Vector256<UInt64> value, [Ca
 
         private void ValidateResult(UInt64[] resultElements, UInt64[] valueElements, Type targetType, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             for (var i = 0; i < ElementCount; i++)
             {
                 if (resultElements[i] != valueElements[i])
                 {
-                    Succeeded = false;
+                    succeeded = false;
                     break;
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"Vector256<UInt64>.As{targetType.Name}: {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"   value: ({string.Join(", ", valueElements)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", resultElements)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/General/Vector256_1/GetAndWithElement.Byte.0.cs b/tests/src/JIT/HardwareIntrinsics/General/Vector256_1/GetAndWithElement.Byte.0.cs
index ed34e42c2bba..162b063a75f4 100644
--- a/tests/src/JIT/HardwareIntrinsics/General/Vector256_1/GetAndWithElement.Byte.0.cs
+++ b/tests/src/JIT/HardwareIntrinsics/General/Vector256_1/GetAndWithElement.Byte.0.cs
@@ -74,10 +74,10 @@ public void RunBasicScenario(int imm = 0, bool expectedOutOfRangeException = fal
 
             if (!succeeded)
             {
-                Succeeded = false;
-
                 TestLibrary.TestFramework.LogInformation($"Vector256<Byte.GetElement({imm}): {nameof(RunBasicScenario)} failed to throw ArgumentOutOfRangeException.");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
 
             succeeded = !expectedOutOfRangeException;
@@ -96,10 +96,10 @@ public void RunBasicScenario(int imm = 0, bool expectedOutOfRangeException = fal
 
             if (!succeeded)
             {
-                Succeeded = false;
-
                 TestLibrary.TestFramework.LogInformation($"Vector256<Byte.WithElement({imm}): {nameof(RunBasicScenario)} failed to throw ArgumentOutOfRangeException.");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
 
@@ -133,10 +133,10 @@ public void RunReflectionScenario(int imm = 0, bool expectedOutOfRangeException
 
             if (!succeeded)
             {
-                Succeeded = false;
-
                 TestLibrary.TestFramework.LogInformation($"Vector256<Byte.GetElement({imm}): {nameof(RunReflectionScenario)} failed to throw ArgumentOutOfRangeException.");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
 
             succeeded = !expectedOutOfRangeException;
@@ -158,10 +158,10 @@ public void RunReflectionScenario(int imm = 0, bool expectedOutOfRangeException
 
             if (!succeeded)
             {
-                Succeeded = false;
-
                 TestLibrary.TestFramework.LogInformation($"Vector256<Byte.WithElement({imm}): {nameof(RunReflectionScenario)} failed to throw ArgumentOutOfRangeException.");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
 
@@ -196,27 +196,31 @@ private void ValidateWithResult(Vector256<Byte> result, Byte[] values, Byte inse
 
         private void ValidateWithResult(Byte[] result, Byte[] values, Byte insertedValue, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             for (int i = 0; i < ElementCount; i++)
             {
                 if ((i != 0) && (result[i] != values[i]))
                 {
-                    Succeeded = false;
+                    succeeded = false;
                     break;
                 }
             }
 
             if (result[0] != insertedValue)
             {
-                Succeeded = false;
+                succeeded = false;
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"Vector256<Byte.WithElement(0): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"   value: ({string.Join(", ", values)})");
                 TestLibrary.TestFramework.LogInformation($"  insert: insertedValue");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/General/Vector256_1/GetAndWithElement.Byte.15.cs b/tests/src/JIT/HardwareIntrinsics/General/Vector256_1/GetAndWithElement.Byte.15.cs
index f9caea7267ea..9661c040d8c4 100644
--- a/tests/src/JIT/HardwareIntrinsics/General/Vector256_1/GetAndWithElement.Byte.15.cs
+++ b/tests/src/JIT/HardwareIntrinsics/General/Vector256_1/GetAndWithElement.Byte.15.cs
@@ -74,10 +74,10 @@ public void RunBasicScenario(int imm = 15, bool expectedOutOfRangeException = fa
 
             if (!succeeded)
             {
-                Succeeded = false;
-
                 TestLibrary.TestFramework.LogInformation($"Vector256<Byte.GetElement({imm}): {nameof(RunBasicScenario)} failed to throw ArgumentOutOfRangeException.");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
 
             succeeded = !expectedOutOfRangeException;
@@ -96,10 +96,10 @@ public void RunBasicScenario(int imm = 15, bool expectedOutOfRangeException = fa
 
             if (!succeeded)
             {
-                Succeeded = false;
-
                 TestLibrary.TestFramework.LogInformation($"Vector256<Byte.WithElement({imm}): {nameof(RunBasicScenario)} failed to throw ArgumentOutOfRangeException.");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
 
@@ -133,10 +133,10 @@ public void RunReflectionScenario(int imm = 15, bool expectedOutOfRangeException
 
             if (!succeeded)
             {
-                Succeeded = false;
-
                 TestLibrary.TestFramework.LogInformation($"Vector256<Byte.GetElement({imm}): {nameof(RunReflectionScenario)} failed to throw ArgumentOutOfRangeException.");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
 
             succeeded = !expectedOutOfRangeException;
@@ -158,10 +158,10 @@ public void RunReflectionScenario(int imm = 15, bool expectedOutOfRangeException
 
             if (!succeeded)
             {
-                Succeeded = false;
-
                 TestLibrary.TestFramework.LogInformation($"Vector256<Byte.WithElement({imm}): {nameof(RunReflectionScenario)} failed to throw ArgumentOutOfRangeException.");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
 
@@ -196,27 +196,31 @@ private void ValidateWithResult(Vector256<Byte> result, Byte[] values, Byte inse
 
         private void ValidateWithResult(Byte[] result, Byte[] values, Byte insertedValue, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             for (int i = 0; i < ElementCount; i++)
             {
                 if ((i != 15) && (result[i] != values[i]))
                 {
-                    Succeeded = false;
+                    succeeded = false;
                     break;
                 }
             }
 
             if (result[15] != insertedValue)
             {
-                Succeeded = false;
+                succeeded = false;
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"Vector256<Byte.WithElement(15): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"   value: ({string.Join(", ", values)})");
                 TestLibrary.TestFramework.LogInformation($"  insert: insertedValue");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/General/Vector256_1/GetAndWithElement.Byte.31.cs b/tests/src/JIT/HardwareIntrinsics/General/Vector256_1/GetAndWithElement.Byte.31.cs
index 2d028322f5c6..c770764f9089 100644
--- a/tests/src/JIT/HardwareIntrinsics/General/Vector256_1/GetAndWithElement.Byte.31.cs
+++ b/tests/src/JIT/HardwareIntrinsics/General/Vector256_1/GetAndWithElement.Byte.31.cs
@@ -74,10 +74,10 @@ public void RunBasicScenario(int imm = 31, bool expectedOutOfRangeException = fa
 
             if (!succeeded)
             {
-                Succeeded = false;
-
                 TestLibrary.TestFramework.LogInformation($"Vector256<Byte.GetElement({imm}): {nameof(RunBasicScenario)} failed to throw ArgumentOutOfRangeException.");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
 
             succeeded = !expectedOutOfRangeException;
@@ -96,10 +96,10 @@ public void RunBasicScenario(int imm = 31, bool expectedOutOfRangeException = fa
 
             if (!succeeded)
             {
-                Succeeded = false;
-
                 TestLibrary.TestFramework.LogInformation($"Vector256<Byte.WithElement({imm}): {nameof(RunBasicScenario)} failed to throw ArgumentOutOfRangeException.");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
 
@@ -133,10 +133,10 @@ public void RunReflectionScenario(int imm = 31, bool expectedOutOfRangeException
 
             if (!succeeded)
             {
-                Succeeded = false;
-
                 TestLibrary.TestFramework.LogInformation($"Vector256<Byte.GetElement({imm}): {nameof(RunReflectionScenario)} failed to throw ArgumentOutOfRangeException.");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
 
             succeeded = !expectedOutOfRangeException;
@@ -158,10 +158,10 @@ public void RunReflectionScenario(int imm = 31, bool expectedOutOfRangeException
 
             if (!succeeded)
             {
-                Succeeded = false;
-
                 TestLibrary.TestFramework.LogInformation($"Vector256<Byte.WithElement({imm}): {nameof(RunReflectionScenario)} failed to throw ArgumentOutOfRangeException.");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
 
@@ -196,27 +196,31 @@ private void ValidateWithResult(Vector256<Byte> result, Byte[] values, Byte inse
 
         private void ValidateWithResult(Byte[] result, Byte[] values, Byte insertedValue, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             for (int i = 0; i < ElementCount; i++)
             {
                 if ((i != 31) && (result[i] != values[i]))
                 {
-                    Succeeded = false;
+                    succeeded = false;
                     break;
                 }
             }
 
             if (result[31] != insertedValue)
             {
-                Succeeded = false;
+                succeeded = false;
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"Vector256<Byte.WithElement(31): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"   value: ({string.Join(", ", values)})");
                 TestLibrary.TestFramework.LogInformation($"  insert: insertedValue");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/General/Vector256_1/GetAndWithElement.Byte.7.cs b/tests/src/JIT/HardwareIntrinsics/General/Vector256_1/GetAndWithElement.Byte.7.cs
index 07ad814163be..12e4d606bdfc 100644
--- a/tests/src/JIT/HardwareIntrinsics/General/Vector256_1/GetAndWithElement.Byte.7.cs
+++ b/tests/src/JIT/HardwareIntrinsics/General/Vector256_1/GetAndWithElement.Byte.7.cs
@@ -74,10 +74,10 @@ public void RunBasicScenario(int imm = 7, bool expectedOutOfRangeException = fal
 
             if (!succeeded)
             {
-                Succeeded = false;
-
                 TestLibrary.TestFramework.LogInformation($"Vector256<Byte.GetElement({imm}): {nameof(RunBasicScenario)} failed to throw ArgumentOutOfRangeException.");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
 
             succeeded = !expectedOutOfRangeException;
@@ -96,10 +96,10 @@ public void RunBasicScenario(int imm = 7, bool expectedOutOfRangeException = fal
 
             if (!succeeded)
             {
-                Succeeded = false;
-
                 TestLibrary.TestFramework.LogInformation($"Vector256<Byte.WithElement({imm}): {nameof(RunBasicScenario)} failed to throw ArgumentOutOfRangeException.");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
 
@@ -133,10 +133,10 @@ public void RunReflectionScenario(int imm = 7, bool expectedOutOfRangeException
 
             if (!succeeded)
             {
-                Succeeded = false;
-
                 TestLibrary.TestFramework.LogInformation($"Vector256<Byte.GetElement({imm}): {nameof(RunReflectionScenario)} failed to throw ArgumentOutOfRangeException.");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
 
             succeeded = !expectedOutOfRangeException;
@@ -158,10 +158,10 @@ public void RunReflectionScenario(int imm = 7, bool expectedOutOfRangeException
 
             if (!succeeded)
             {
-                Succeeded = false;
-
                 TestLibrary.TestFramework.LogInformation($"Vector256<Byte.WithElement({imm}): {nameof(RunReflectionScenario)} failed to throw ArgumentOutOfRangeException.");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
 
@@ -196,27 +196,31 @@ private void ValidateWithResult(Vector256<Byte> result, Byte[] values, Byte inse
 
         private void ValidateWithResult(Byte[] result, Byte[] values, Byte insertedValue, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             for (int i = 0; i < ElementCount; i++)
             {
                 if ((i != 7) && (result[i] != values[i]))
                 {
-                    Succeeded = false;
+                    succeeded = false;
                     break;
                 }
             }
 
             if (result[7] != insertedValue)
             {
-                Succeeded = false;
+                succeeded = false;
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"Vector256<Byte.WithElement(7): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"   value: ({string.Join(", ", values)})");
                 TestLibrary.TestFramework.LogInformation($"  insert: insertedValue");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/General/Vector256_1/GetAndWithElement.Double.0.cs b/tests/src/JIT/HardwareIntrinsics/General/Vector256_1/GetAndWithElement.Double.0.cs
index c04dd69ced89..e8b00cfde6e2 100644
--- a/tests/src/JIT/HardwareIntrinsics/General/Vector256_1/GetAndWithElement.Double.0.cs
+++ b/tests/src/JIT/HardwareIntrinsics/General/Vector256_1/GetAndWithElement.Double.0.cs
@@ -74,10 +74,10 @@ public void RunBasicScenario(int imm = 0, bool expectedOutOfRangeException = fal
 
             if (!succeeded)
             {
-                Succeeded = false;
-
                 TestLibrary.TestFramework.LogInformation($"Vector256<Double.GetElement({imm}): {nameof(RunBasicScenario)} failed to throw ArgumentOutOfRangeException.");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
 
             succeeded = !expectedOutOfRangeException;
@@ -96,10 +96,10 @@ public void RunBasicScenario(int imm = 0, bool expectedOutOfRangeException = fal
 
             if (!succeeded)
             {
-                Succeeded = false;
-
                 TestLibrary.TestFramework.LogInformation($"Vector256<Double.WithElement({imm}): {nameof(RunBasicScenario)} failed to throw ArgumentOutOfRangeException.");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
 
@@ -133,10 +133,10 @@ public void RunReflectionScenario(int imm = 0, bool expectedOutOfRangeException
 
             if (!succeeded)
             {
-                Succeeded = false;
-
                 TestLibrary.TestFramework.LogInformation($"Vector256<Double.GetElement({imm}): {nameof(RunReflectionScenario)} failed to throw ArgumentOutOfRangeException.");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
 
             succeeded = !expectedOutOfRangeException;
@@ -158,10 +158,10 @@ public void RunReflectionScenario(int imm = 0, bool expectedOutOfRangeException
 
             if (!succeeded)
             {
-                Succeeded = false;
-
                 TestLibrary.TestFramework.LogInformation($"Vector256<Double.WithElement({imm}): {nameof(RunReflectionScenario)} failed to throw ArgumentOutOfRangeException.");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
 
@@ -196,27 +196,31 @@ private void ValidateWithResult(Vector256<Double> result, Double[] values, Doubl
 
         private void ValidateWithResult(Double[] result, Double[] values, Double insertedValue, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             for (int i = 0; i < ElementCount; i++)
             {
                 if ((i != 0) && (result[i] != values[i]))
                 {
-                    Succeeded = false;
+                    succeeded = false;
                     break;
                 }
             }
 
             if (result[0] != insertedValue)
             {
-                Succeeded = false;
+                succeeded = false;
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"Vector256<Double.WithElement(0): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"   value: ({string.Join(", ", values)})");
                 TestLibrary.TestFramework.LogInformation($"  insert: insertedValue");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/General/Vector256_1/GetAndWithElement.Double.1.cs b/tests/src/JIT/HardwareIntrinsics/General/Vector256_1/GetAndWithElement.Double.1.cs
index 166453fcafe9..1e6c0ddf7477 100644
--- a/tests/src/JIT/HardwareIntrinsics/General/Vector256_1/GetAndWithElement.Double.1.cs
+++ b/tests/src/JIT/HardwareIntrinsics/General/Vector256_1/GetAndWithElement.Double.1.cs
@@ -74,10 +74,10 @@ public void RunBasicScenario(int imm = 1, bool expectedOutOfRangeException = fal
 
             if (!succeeded)
             {
-                Succeeded = false;
-
                 TestLibrary.TestFramework.LogInformation($"Vector256<Double.GetElement({imm}): {nameof(RunBasicScenario)} failed to throw ArgumentOutOfRangeException.");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
 
             succeeded = !expectedOutOfRangeException;
@@ -96,10 +96,10 @@ public void RunBasicScenario(int imm = 1, bool expectedOutOfRangeException = fal
 
             if (!succeeded)
             {
-                Succeeded = false;
-
                 TestLibrary.TestFramework.LogInformation($"Vector256<Double.WithElement({imm}): {nameof(RunBasicScenario)} failed to throw ArgumentOutOfRangeException.");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
 
@@ -133,10 +133,10 @@ public void RunReflectionScenario(int imm = 1, bool expectedOutOfRangeException
 
             if (!succeeded)
             {
-                Succeeded = false;
-
                 TestLibrary.TestFramework.LogInformation($"Vector256<Double.GetElement({imm}): {nameof(RunReflectionScenario)} failed to throw ArgumentOutOfRangeException.");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
 
             succeeded = !expectedOutOfRangeException;
@@ -158,10 +158,10 @@ public void RunReflectionScenario(int imm = 1, bool expectedOutOfRangeException
 
             if (!succeeded)
             {
-                Succeeded = false;
-
                 TestLibrary.TestFramework.LogInformation($"Vector256<Double.WithElement({imm}): {nameof(RunReflectionScenario)} failed to throw ArgumentOutOfRangeException.");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
 
@@ -196,27 +196,31 @@ private void ValidateWithResult(Vector256<Double> result, Double[] values, Doubl
 
         private void ValidateWithResult(Double[] result, Double[] values, Double insertedValue, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             for (int i = 0; i < ElementCount; i++)
             {
                 if ((i != 1) && (result[i] != values[i]))
                 {
-                    Succeeded = false;
+                    succeeded = false;
                     break;
                 }
             }
 
             if (result[1] != insertedValue)
             {
-                Succeeded = false;
+                succeeded = false;
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"Vector256<Double.WithElement(1): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"   value: ({string.Join(", ", values)})");
                 TestLibrary.TestFramework.LogInformation($"  insert: insertedValue");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/General/Vector256_1/GetAndWithElement.Double.3.cs b/tests/src/JIT/HardwareIntrinsics/General/Vector256_1/GetAndWithElement.Double.3.cs
index 4385264ed173..e892fc58513c 100644
--- a/tests/src/JIT/HardwareIntrinsics/General/Vector256_1/GetAndWithElement.Double.3.cs
+++ b/tests/src/JIT/HardwareIntrinsics/General/Vector256_1/GetAndWithElement.Double.3.cs
@@ -74,10 +74,10 @@ public void RunBasicScenario(int imm = 3, bool expectedOutOfRangeException = fal
 
             if (!succeeded)
             {
-                Succeeded = false;
-
                 TestLibrary.TestFramework.LogInformation($"Vector256<Double.GetElement({imm}): {nameof(RunBasicScenario)} failed to throw ArgumentOutOfRangeException.");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
 
             succeeded = !expectedOutOfRangeException;
@@ -96,10 +96,10 @@ public void RunBasicScenario(int imm = 3, bool expectedOutOfRangeException = fal
 
             if (!succeeded)
             {
-                Succeeded = false;
-
                 TestLibrary.TestFramework.LogInformation($"Vector256<Double.WithElement({imm}): {nameof(RunBasicScenario)} failed to throw ArgumentOutOfRangeException.");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
 
@@ -133,10 +133,10 @@ public void RunReflectionScenario(int imm = 3, bool expectedOutOfRangeException
 
             if (!succeeded)
             {
-                Succeeded = false;
-
                 TestLibrary.TestFramework.LogInformation($"Vector256<Double.GetElement({imm}): {nameof(RunReflectionScenario)} failed to throw ArgumentOutOfRangeException.");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
 
             succeeded = !expectedOutOfRangeException;
@@ -158,10 +158,10 @@ public void RunReflectionScenario(int imm = 3, bool expectedOutOfRangeException
 
             if (!succeeded)
             {
-                Succeeded = false;
-
                 TestLibrary.TestFramework.LogInformation($"Vector256<Double.WithElement({imm}): {nameof(RunReflectionScenario)} failed to throw ArgumentOutOfRangeException.");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
 
@@ -196,27 +196,31 @@ private void ValidateWithResult(Vector256<Double> result, Double[] values, Doubl
 
         private void ValidateWithResult(Double[] result, Double[] values, Double insertedValue, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             for (int i = 0; i < ElementCount; i++)
             {
                 if ((i != 3) && (result[i] != values[i]))
                 {
-                    Succeeded = false;
+                    succeeded = false;
                     break;
                 }
             }
 
             if (result[3] != insertedValue)
             {
-                Succeeded = false;
+                succeeded = false;
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"Vector256<Double.WithElement(3): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"   value: ({string.Join(", ", values)})");
                 TestLibrary.TestFramework.LogInformation($"  insert: insertedValue");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/General/Vector256_1/GetAndWithElement.Int16.0.cs b/tests/src/JIT/HardwareIntrinsics/General/Vector256_1/GetAndWithElement.Int16.0.cs
index efdcd68fd0bb..2408f9c5876b 100644
--- a/tests/src/JIT/HardwareIntrinsics/General/Vector256_1/GetAndWithElement.Int16.0.cs
+++ b/tests/src/JIT/HardwareIntrinsics/General/Vector256_1/GetAndWithElement.Int16.0.cs
@@ -74,10 +74,10 @@ public void RunBasicScenario(int imm = 0, bool expectedOutOfRangeException = fal
 
             if (!succeeded)
             {
-                Succeeded = false;
-
                 TestLibrary.TestFramework.LogInformation($"Vector256<Int16.GetElement({imm}): {nameof(RunBasicScenario)} failed to throw ArgumentOutOfRangeException.");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
 
             succeeded = !expectedOutOfRangeException;
@@ -96,10 +96,10 @@ public void RunBasicScenario(int imm = 0, bool expectedOutOfRangeException = fal
 
             if (!succeeded)
             {
-                Succeeded = false;
-
                 TestLibrary.TestFramework.LogInformation($"Vector256<Int16.WithElement({imm}): {nameof(RunBasicScenario)} failed to throw ArgumentOutOfRangeException.");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
 
@@ -133,10 +133,10 @@ public void RunReflectionScenario(int imm = 0, bool expectedOutOfRangeException
 
             if (!succeeded)
             {
-                Succeeded = false;
-
                 TestLibrary.TestFramework.LogInformation($"Vector256<Int16.GetElement({imm}): {nameof(RunReflectionScenario)} failed to throw ArgumentOutOfRangeException.");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
 
             succeeded = !expectedOutOfRangeException;
@@ -158,10 +158,10 @@ public void RunReflectionScenario(int imm = 0, bool expectedOutOfRangeException
 
             if (!succeeded)
             {
-                Succeeded = false;
-
                 TestLibrary.TestFramework.LogInformation($"Vector256<Int16.WithElement({imm}): {nameof(RunReflectionScenario)} failed to throw ArgumentOutOfRangeException.");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
 
@@ -196,27 +196,31 @@ private void ValidateWithResult(Vector256<Int16> result, Int16[] values, Int16 i
 
         private void ValidateWithResult(Int16[] result, Int16[] values, Int16 insertedValue, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             for (int i = 0; i < ElementCount; i++)
             {
                 if ((i != 0) && (result[i] != values[i]))
                 {
-                    Succeeded = false;
+                    succeeded = false;
                     break;
                 }
             }
 
             if (result[0] != insertedValue)
             {
-                Succeeded = false;
+                succeeded = false;
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"Vector256<Int16.WithElement(0): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"   value: ({string.Join(", ", values)})");
                 TestLibrary.TestFramework.LogInformation($"  insert: insertedValue");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/General/Vector256_1/GetAndWithElement.Int16.15.cs b/tests/src/JIT/HardwareIntrinsics/General/Vector256_1/GetAndWithElement.Int16.15.cs
index 62cf3b1ab76a..2c4ac09a1498 100644
--- a/tests/src/JIT/HardwareIntrinsics/General/Vector256_1/GetAndWithElement.Int16.15.cs
+++ b/tests/src/JIT/HardwareIntrinsics/General/Vector256_1/GetAndWithElement.Int16.15.cs
@@ -74,10 +74,10 @@ public void RunBasicScenario(int imm = 15, bool expectedOutOfRangeException = fa
 
             if (!succeeded)
             {
-                Succeeded = false;
-
                 TestLibrary.TestFramework.LogInformation($"Vector256<Int16.GetElement({imm}): {nameof(RunBasicScenario)} failed to throw ArgumentOutOfRangeException.");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
 
             succeeded = !expectedOutOfRangeException;
@@ -96,10 +96,10 @@ public void RunBasicScenario(int imm = 15, bool expectedOutOfRangeException = fa
 
             if (!succeeded)
             {
-                Succeeded = false;
-
                 TestLibrary.TestFramework.LogInformation($"Vector256<Int16.WithElement({imm}): {nameof(RunBasicScenario)} failed to throw ArgumentOutOfRangeException.");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
 
@@ -133,10 +133,10 @@ public void RunReflectionScenario(int imm = 15, bool expectedOutOfRangeException
 
             if (!succeeded)
             {
-                Succeeded = false;
-
                 TestLibrary.TestFramework.LogInformation($"Vector256<Int16.GetElement({imm}): {nameof(RunReflectionScenario)} failed to throw ArgumentOutOfRangeException.");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
 
             succeeded = !expectedOutOfRangeException;
@@ -158,10 +158,10 @@ public void RunReflectionScenario(int imm = 15, bool expectedOutOfRangeException
 
             if (!succeeded)
             {
-                Succeeded = false;
-
                 TestLibrary.TestFramework.LogInformation($"Vector256<Int16.WithElement({imm}): {nameof(RunReflectionScenario)} failed to throw ArgumentOutOfRangeException.");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
 
@@ -196,27 +196,31 @@ private void ValidateWithResult(Vector256<Int16> result, Int16[] values, Int16 i
 
         private void ValidateWithResult(Int16[] result, Int16[] values, Int16 insertedValue, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             for (int i = 0; i < ElementCount; i++)
             {
                 if ((i != 15) && (result[i] != values[i]))
                 {
-                    Succeeded = false;
+                    succeeded = false;
                     break;
                 }
             }
 
             if (result[15] != insertedValue)
             {
-                Succeeded = false;
+                succeeded = false;
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"Vector256<Int16.WithElement(15): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"   value: ({string.Join(", ", values)})");
                 TestLibrary.TestFramework.LogInformation($"  insert: insertedValue");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/General/Vector256_1/GetAndWithElement.Int16.3.cs b/tests/src/JIT/HardwareIntrinsics/General/Vector256_1/GetAndWithElement.Int16.3.cs
index 8de234efdd15..640c32e64976 100644
--- a/tests/src/JIT/HardwareIntrinsics/General/Vector256_1/GetAndWithElement.Int16.3.cs
+++ b/tests/src/JIT/HardwareIntrinsics/General/Vector256_1/GetAndWithElement.Int16.3.cs
@@ -74,10 +74,10 @@ public void RunBasicScenario(int imm = 3, bool expectedOutOfRangeException = fal
 
             if (!succeeded)
             {
-                Succeeded = false;
-
                 TestLibrary.TestFramework.LogInformation($"Vector256<Int16.GetElement({imm}): {nameof(RunBasicScenario)} failed to throw ArgumentOutOfRangeException.");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
 
             succeeded = !expectedOutOfRangeException;
@@ -96,10 +96,10 @@ public void RunBasicScenario(int imm = 3, bool expectedOutOfRangeException = fal
 
             if (!succeeded)
             {
-                Succeeded = false;
-
                 TestLibrary.TestFramework.LogInformation($"Vector256<Int16.WithElement({imm}): {nameof(RunBasicScenario)} failed to throw ArgumentOutOfRangeException.");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
 
@@ -133,10 +133,10 @@ public void RunReflectionScenario(int imm = 3, bool expectedOutOfRangeException
 
             if (!succeeded)
             {
-                Succeeded = false;
-
                 TestLibrary.TestFramework.LogInformation($"Vector256<Int16.GetElement({imm}): {nameof(RunReflectionScenario)} failed to throw ArgumentOutOfRangeException.");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
 
             succeeded = !expectedOutOfRangeException;
@@ -158,10 +158,10 @@ public void RunReflectionScenario(int imm = 3, bool expectedOutOfRangeException
 
             if (!succeeded)
             {
-                Succeeded = false;
-
                 TestLibrary.TestFramework.LogInformation($"Vector256<Int16.WithElement({imm}): {nameof(RunReflectionScenario)} failed to throw ArgumentOutOfRangeException.");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
 
@@ -196,27 +196,31 @@ private void ValidateWithResult(Vector256<Int16> result, Int16[] values, Int16 i
 
         private void ValidateWithResult(Int16[] result, Int16[] values, Int16 insertedValue, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             for (int i = 0; i < ElementCount; i++)
             {
                 if ((i != 3) && (result[i] != values[i]))
                 {
-                    Succeeded = false;
+                    succeeded = false;
                     break;
                 }
             }
 
             if (result[3] != insertedValue)
             {
-                Succeeded = false;
+                succeeded = false;
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"Vector256<Int16.WithElement(3): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"   value: ({string.Join(", ", values)})");
                 TestLibrary.TestFramework.LogInformation($"  insert: insertedValue");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/General/Vector256_1/GetAndWithElement.Int16.7.cs b/tests/src/JIT/HardwareIntrinsics/General/Vector256_1/GetAndWithElement.Int16.7.cs
index ce43c7cca77a..a1cb648b5b84 100644
--- a/tests/src/JIT/HardwareIntrinsics/General/Vector256_1/GetAndWithElement.Int16.7.cs
+++ b/tests/src/JIT/HardwareIntrinsics/General/Vector256_1/GetAndWithElement.Int16.7.cs
@@ -74,10 +74,10 @@ public void RunBasicScenario(int imm = 7, bool expectedOutOfRangeException = fal
 
             if (!succeeded)
             {
-                Succeeded = false;
-
                 TestLibrary.TestFramework.LogInformation($"Vector256<Int16.GetElement({imm}): {nameof(RunBasicScenario)} failed to throw ArgumentOutOfRangeException.");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
 
             succeeded = !expectedOutOfRangeException;
@@ -96,10 +96,10 @@ public void RunBasicScenario(int imm = 7, bool expectedOutOfRangeException = fal
 
             if (!succeeded)
             {
-                Succeeded = false;
-
                 TestLibrary.TestFramework.LogInformation($"Vector256<Int16.WithElement({imm}): {nameof(RunBasicScenario)} failed to throw ArgumentOutOfRangeException.");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
 
@@ -133,10 +133,10 @@ public void RunReflectionScenario(int imm = 7, bool expectedOutOfRangeException
 
             if (!succeeded)
             {
-                Succeeded = false;
-
                 TestLibrary.TestFramework.LogInformation($"Vector256<Int16.GetElement({imm}): {nameof(RunReflectionScenario)} failed to throw ArgumentOutOfRangeException.");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
 
             succeeded = !expectedOutOfRangeException;
@@ -158,10 +158,10 @@ public void RunReflectionScenario(int imm = 7, bool expectedOutOfRangeException
 
             if (!succeeded)
             {
-                Succeeded = false;
-
                 TestLibrary.TestFramework.LogInformation($"Vector256<Int16.WithElement({imm}): {nameof(RunReflectionScenario)} failed to throw ArgumentOutOfRangeException.");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
 
@@ -196,27 +196,31 @@ private void ValidateWithResult(Vector256<Int16> result, Int16[] values, Int16 i
 
         private void ValidateWithResult(Int16[] result, Int16[] values, Int16 insertedValue, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             for (int i = 0; i < ElementCount; i++)
             {
                 if ((i != 7) && (result[i] != values[i]))
                 {
-                    Succeeded = false;
+                    succeeded = false;
                     break;
                 }
             }
 
             if (result[7] != insertedValue)
             {
-                Succeeded = false;
+                succeeded = false;
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"Vector256<Int16.WithElement(7): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"   value: ({string.Join(", ", values)})");
                 TestLibrary.TestFramework.LogInformation($"  insert: insertedValue");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/General/Vector256_1/GetAndWithElement.Int32.0.cs b/tests/src/JIT/HardwareIntrinsics/General/Vector256_1/GetAndWithElement.Int32.0.cs
index e8ce032a1fb7..b925becc24e5 100644
--- a/tests/src/JIT/HardwareIntrinsics/General/Vector256_1/GetAndWithElement.Int32.0.cs
+++ b/tests/src/JIT/HardwareIntrinsics/General/Vector256_1/GetAndWithElement.Int32.0.cs
@@ -74,10 +74,10 @@ public void RunBasicScenario(int imm = 0, bool expectedOutOfRangeException = fal
 
             if (!succeeded)
             {
-                Succeeded = false;
-
                 TestLibrary.TestFramework.LogInformation($"Vector256<Int32.GetElement({imm}): {nameof(RunBasicScenario)} failed to throw ArgumentOutOfRangeException.");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
 
             succeeded = !expectedOutOfRangeException;
@@ -96,10 +96,10 @@ public void RunBasicScenario(int imm = 0, bool expectedOutOfRangeException = fal
 
             if (!succeeded)
             {
-                Succeeded = false;
-
                 TestLibrary.TestFramework.LogInformation($"Vector256<Int32.WithElement({imm}): {nameof(RunBasicScenario)} failed to throw ArgumentOutOfRangeException.");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
 
@@ -133,10 +133,10 @@ public void RunReflectionScenario(int imm = 0, bool expectedOutOfRangeException
 
             if (!succeeded)
             {
-                Succeeded = false;
-
                 TestLibrary.TestFramework.LogInformation($"Vector256<Int32.GetElement({imm}): {nameof(RunReflectionScenario)} failed to throw ArgumentOutOfRangeException.");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
 
             succeeded = !expectedOutOfRangeException;
@@ -158,10 +158,10 @@ public void RunReflectionScenario(int imm = 0, bool expectedOutOfRangeException
 
             if (!succeeded)
             {
-                Succeeded = false;
-
                 TestLibrary.TestFramework.LogInformation($"Vector256<Int32.WithElement({imm}): {nameof(RunReflectionScenario)} failed to throw ArgumentOutOfRangeException.");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
 
@@ -196,27 +196,31 @@ private void ValidateWithResult(Vector256<Int32> result, Int32[] values, Int32 i
 
         private void ValidateWithResult(Int32[] result, Int32[] values, Int32 insertedValue, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             for (int i = 0; i < ElementCount; i++)
             {
                 if ((i != 0) && (result[i] != values[i]))
                 {
-                    Succeeded = false;
+                    succeeded = false;
                     break;
                 }
             }
 
             if (result[0] != insertedValue)
             {
-                Succeeded = false;
+                succeeded = false;
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"Vector256<Int32.WithElement(0): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"   value: ({string.Join(", ", values)})");
                 TestLibrary.TestFramework.LogInformation($"  insert: insertedValue");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/General/Vector256_1/GetAndWithElement.Int32.1.cs b/tests/src/JIT/HardwareIntrinsics/General/Vector256_1/GetAndWithElement.Int32.1.cs
index 919d0643aaed..f6c74f0c7a7a 100644
--- a/tests/src/JIT/HardwareIntrinsics/General/Vector256_1/GetAndWithElement.Int32.1.cs
+++ b/tests/src/JIT/HardwareIntrinsics/General/Vector256_1/GetAndWithElement.Int32.1.cs
@@ -74,10 +74,10 @@ public void RunBasicScenario(int imm = 1, bool expectedOutOfRangeException = fal
 
             if (!succeeded)
             {
-                Succeeded = false;
-
                 TestLibrary.TestFramework.LogInformation($"Vector256<Int32.GetElement({imm}): {nameof(RunBasicScenario)} failed to throw ArgumentOutOfRangeException.");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
 
             succeeded = !expectedOutOfRangeException;
@@ -96,10 +96,10 @@ public void RunBasicScenario(int imm = 1, bool expectedOutOfRangeException = fal
 
             if (!succeeded)
             {
-                Succeeded = false;
-
                 TestLibrary.TestFramework.LogInformation($"Vector256<Int32.WithElement({imm}): {nameof(RunBasicScenario)} failed to throw ArgumentOutOfRangeException.");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
 
@@ -133,10 +133,10 @@ public void RunReflectionScenario(int imm = 1, bool expectedOutOfRangeException
 
             if (!succeeded)
             {
-                Succeeded = false;
-
                 TestLibrary.TestFramework.LogInformation($"Vector256<Int32.GetElement({imm}): {nameof(RunReflectionScenario)} failed to throw ArgumentOutOfRangeException.");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
 
             succeeded = !expectedOutOfRangeException;
@@ -158,10 +158,10 @@ public void RunReflectionScenario(int imm = 1, bool expectedOutOfRangeException
 
             if (!succeeded)
             {
-                Succeeded = false;
-
                 TestLibrary.TestFramework.LogInformation($"Vector256<Int32.WithElement({imm}): {nameof(RunReflectionScenario)} failed to throw ArgumentOutOfRangeException.");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
 
@@ -196,27 +196,31 @@ private void ValidateWithResult(Vector256<Int32> result, Int32[] values, Int32 i
 
         private void ValidateWithResult(Int32[] result, Int32[] values, Int32 insertedValue, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             for (int i = 0; i < ElementCount; i++)
             {
                 if ((i != 1) && (result[i] != values[i]))
                 {
-                    Succeeded = false;
+                    succeeded = false;
                     break;
                 }
             }
 
             if (result[1] != insertedValue)
             {
-                Succeeded = false;
+                succeeded = false;
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"Vector256<Int32.WithElement(1): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"   value: ({string.Join(", ", values)})");
                 TestLibrary.TestFramework.LogInformation($"  insert: insertedValue");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/General/Vector256_1/GetAndWithElement.Int32.3.cs b/tests/src/JIT/HardwareIntrinsics/General/Vector256_1/GetAndWithElement.Int32.3.cs
index 2019ac9aa4ff..9e7cacbd1981 100644
--- a/tests/src/JIT/HardwareIntrinsics/General/Vector256_1/GetAndWithElement.Int32.3.cs
+++ b/tests/src/JIT/HardwareIntrinsics/General/Vector256_1/GetAndWithElement.Int32.3.cs
@@ -74,10 +74,10 @@ public void RunBasicScenario(int imm = 3, bool expectedOutOfRangeException = fal
 
             if (!succeeded)
             {
-                Succeeded = false;
-
                 TestLibrary.TestFramework.LogInformation($"Vector256<Int32.GetElement({imm}): {nameof(RunBasicScenario)} failed to throw ArgumentOutOfRangeException.");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
 
             succeeded = !expectedOutOfRangeException;
@@ -96,10 +96,10 @@ public void RunBasicScenario(int imm = 3, bool expectedOutOfRangeException = fal
 
             if (!succeeded)
             {
-                Succeeded = false;
-
                 TestLibrary.TestFramework.LogInformation($"Vector256<Int32.WithElement({imm}): {nameof(RunBasicScenario)} failed to throw ArgumentOutOfRangeException.");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
 
@@ -133,10 +133,10 @@ public void RunReflectionScenario(int imm = 3, bool expectedOutOfRangeException
 
             if (!succeeded)
             {
-                Succeeded = false;
-
                 TestLibrary.TestFramework.LogInformation($"Vector256<Int32.GetElement({imm}): {nameof(RunReflectionScenario)} failed to throw ArgumentOutOfRangeException.");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
 
             succeeded = !expectedOutOfRangeException;
@@ -158,10 +158,10 @@ public void RunReflectionScenario(int imm = 3, bool expectedOutOfRangeException
 
             if (!succeeded)
             {
-                Succeeded = false;
-
                 TestLibrary.TestFramework.LogInformation($"Vector256<Int32.WithElement({imm}): {nameof(RunReflectionScenario)} failed to throw ArgumentOutOfRangeException.");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
 
@@ -196,27 +196,31 @@ private void ValidateWithResult(Vector256<Int32> result, Int32[] values, Int32 i
 
         private void ValidateWithResult(Int32[] result, Int32[] values, Int32 insertedValue, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             for (int i = 0; i < ElementCount; i++)
             {
                 if ((i != 3) && (result[i] != values[i]))
                 {
-                    Succeeded = false;
+                    succeeded = false;
                     break;
                 }
             }
 
             if (result[3] != insertedValue)
             {
-                Succeeded = false;
+                succeeded = false;
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"Vector256<Int32.WithElement(3): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"   value: ({string.Join(", ", values)})");
                 TestLibrary.TestFramework.LogInformation($"  insert: insertedValue");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/General/Vector256_1/GetAndWithElement.Int32.7.cs b/tests/src/JIT/HardwareIntrinsics/General/Vector256_1/GetAndWithElement.Int32.7.cs
index 9eadcec19472..a15a8fff2d77 100644
--- a/tests/src/JIT/HardwareIntrinsics/General/Vector256_1/GetAndWithElement.Int32.7.cs
+++ b/tests/src/JIT/HardwareIntrinsics/General/Vector256_1/GetAndWithElement.Int32.7.cs
@@ -74,10 +74,10 @@ public void RunBasicScenario(int imm = 7, bool expectedOutOfRangeException = fal
 
             if (!succeeded)
             {
-                Succeeded = false;
-
                 TestLibrary.TestFramework.LogInformation($"Vector256<Int32.GetElement({imm}): {nameof(RunBasicScenario)} failed to throw ArgumentOutOfRangeException.");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
 
             succeeded = !expectedOutOfRangeException;
@@ -96,10 +96,10 @@ public void RunBasicScenario(int imm = 7, bool expectedOutOfRangeException = fal
 
             if (!succeeded)
             {
-                Succeeded = false;
-
                 TestLibrary.TestFramework.LogInformation($"Vector256<Int32.WithElement({imm}): {nameof(RunBasicScenario)} failed to throw ArgumentOutOfRangeException.");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
 
@@ -133,10 +133,10 @@ public void RunReflectionScenario(int imm = 7, bool expectedOutOfRangeException
 
             if (!succeeded)
             {
-                Succeeded = false;
-
                 TestLibrary.TestFramework.LogInformation($"Vector256<Int32.GetElement({imm}): {nameof(RunReflectionScenario)} failed to throw ArgumentOutOfRangeException.");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
 
             succeeded = !expectedOutOfRangeException;
@@ -158,10 +158,10 @@ public void RunReflectionScenario(int imm = 7, bool expectedOutOfRangeException
 
             if (!succeeded)
             {
-                Succeeded = false;
-
                 TestLibrary.TestFramework.LogInformation($"Vector256<Int32.WithElement({imm}): {nameof(RunReflectionScenario)} failed to throw ArgumentOutOfRangeException.");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
 
@@ -196,27 +196,31 @@ private void ValidateWithResult(Vector256<Int32> result, Int32[] values, Int32 i
 
         private void ValidateWithResult(Int32[] result, Int32[] values, Int32 insertedValue, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             for (int i = 0; i < ElementCount; i++)
             {
                 if ((i != 7) && (result[i] != values[i]))
                 {
-                    Succeeded = false;
+                    succeeded = false;
                     break;
                 }
             }
 
             if (result[7] != insertedValue)
             {
-                Succeeded = false;
+                succeeded = false;
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"Vector256<Int32.WithElement(7): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"   value: ({string.Join(", ", values)})");
                 TestLibrary.TestFramework.LogInformation($"  insert: insertedValue");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/General/Vector256_1/GetAndWithElement.Int64.0.cs b/tests/src/JIT/HardwareIntrinsics/General/Vector256_1/GetAndWithElement.Int64.0.cs
index d86565759c81..208f01c5ec96 100644
--- a/tests/src/JIT/HardwareIntrinsics/General/Vector256_1/GetAndWithElement.Int64.0.cs
+++ b/tests/src/JIT/HardwareIntrinsics/General/Vector256_1/GetAndWithElement.Int64.0.cs
@@ -74,10 +74,10 @@ public void RunBasicScenario(int imm = 0, bool expectedOutOfRangeException = fal
 
             if (!succeeded)
             {
-                Succeeded = false;
-
                 TestLibrary.TestFramework.LogInformation($"Vector256<Int64.GetElement({imm}): {nameof(RunBasicScenario)} failed to throw ArgumentOutOfRangeException.");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
 
             succeeded = !expectedOutOfRangeException;
@@ -96,10 +96,10 @@ public void RunBasicScenario(int imm = 0, bool expectedOutOfRangeException = fal
 
             if (!succeeded)
             {
-                Succeeded = false;
-
                 TestLibrary.TestFramework.LogInformation($"Vector256<Int64.WithElement({imm}): {nameof(RunBasicScenario)} failed to throw ArgumentOutOfRangeException.");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
 
@@ -133,10 +133,10 @@ public void RunReflectionScenario(int imm = 0, bool expectedOutOfRangeException
 
             if (!succeeded)
             {
-                Succeeded = false;
-
                 TestLibrary.TestFramework.LogInformation($"Vector256<Int64.GetElement({imm}): {nameof(RunReflectionScenario)} failed to throw ArgumentOutOfRangeException.");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
 
             succeeded = !expectedOutOfRangeException;
@@ -158,10 +158,10 @@ public void RunReflectionScenario(int imm = 0, bool expectedOutOfRangeException
 
             if (!succeeded)
             {
-                Succeeded = false;
-
                 TestLibrary.TestFramework.LogInformation($"Vector256<Int64.WithElement({imm}): {nameof(RunReflectionScenario)} failed to throw ArgumentOutOfRangeException.");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
 
@@ -196,27 +196,31 @@ private void ValidateWithResult(Vector256<Int64> result, Int64[] values, Int64 i
 
         private void ValidateWithResult(Int64[] result, Int64[] values, Int64 insertedValue, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             for (int i = 0; i < ElementCount; i++)
             {
                 if ((i != 0) && (result[i] != values[i]))
                 {
-                    Succeeded = false;
+                    succeeded = false;
                     break;
                 }
             }
 
             if (result[0] != insertedValue)
             {
-                Succeeded = false;
+                succeeded = false;
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"Vector256<Int64.WithElement(0): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"   value: ({string.Join(", ", values)})");
                 TestLibrary.TestFramework.LogInformation($"  insert: insertedValue");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/General/Vector256_1/GetAndWithElement.Int64.1.cs b/tests/src/JIT/HardwareIntrinsics/General/Vector256_1/GetAndWithElement.Int64.1.cs
index c3c175626511..ea3bd742cc44 100644
--- a/tests/src/JIT/HardwareIntrinsics/General/Vector256_1/GetAndWithElement.Int64.1.cs
+++ b/tests/src/JIT/HardwareIntrinsics/General/Vector256_1/GetAndWithElement.Int64.1.cs
@@ -74,10 +74,10 @@ public void RunBasicScenario(int imm = 1, bool expectedOutOfRangeException = fal
 
             if (!succeeded)
             {
-                Succeeded = false;
-
                 TestLibrary.TestFramework.LogInformation($"Vector256<Int64.GetElement({imm}): {nameof(RunBasicScenario)} failed to throw ArgumentOutOfRangeException.");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
 
             succeeded = !expectedOutOfRangeException;
@@ -96,10 +96,10 @@ public void RunBasicScenario(int imm = 1, bool expectedOutOfRangeException = fal
 
             if (!succeeded)
             {
-                Succeeded = false;
-
                 TestLibrary.TestFramework.LogInformation($"Vector256<Int64.WithElement({imm}): {nameof(RunBasicScenario)} failed to throw ArgumentOutOfRangeException.");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
 
@@ -133,10 +133,10 @@ public void RunReflectionScenario(int imm = 1, bool expectedOutOfRangeException
 
             if (!succeeded)
             {
-                Succeeded = false;
-
                 TestLibrary.TestFramework.LogInformation($"Vector256<Int64.GetElement({imm}): {nameof(RunReflectionScenario)} failed to throw ArgumentOutOfRangeException.");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
 
             succeeded = !expectedOutOfRangeException;
@@ -158,10 +158,10 @@ public void RunReflectionScenario(int imm = 1, bool expectedOutOfRangeException
 
             if (!succeeded)
             {
-                Succeeded = false;
-
                 TestLibrary.TestFramework.LogInformation($"Vector256<Int64.WithElement({imm}): {nameof(RunReflectionScenario)} failed to throw ArgumentOutOfRangeException.");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
 
@@ -196,27 +196,31 @@ private void ValidateWithResult(Vector256<Int64> result, Int64[] values, Int64 i
 
         private void ValidateWithResult(Int64[] result, Int64[] values, Int64 insertedValue, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             for (int i = 0; i < ElementCount; i++)
             {
                 if ((i != 1) && (result[i] != values[i]))
                 {
-                    Succeeded = false;
+                    succeeded = false;
                     break;
                 }
             }
 
             if (result[1] != insertedValue)
             {
-                Succeeded = false;
+                succeeded = false;
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"Vector256<Int64.WithElement(1): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"   value: ({string.Join(", ", values)})");
                 TestLibrary.TestFramework.LogInformation($"  insert: insertedValue");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/General/Vector256_1/GetAndWithElement.Int64.3.cs b/tests/src/JIT/HardwareIntrinsics/General/Vector256_1/GetAndWithElement.Int64.3.cs
index 39fa940a5c71..b673403b1aee 100644
--- a/tests/src/JIT/HardwareIntrinsics/General/Vector256_1/GetAndWithElement.Int64.3.cs
+++ b/tests/src/JIT/HardwareIntrinsics/General/Vector256_1/GetAndWithElement.Int64.3.cs
@@ -74,10 +74,10 @@ public void RunBasicScenario(int imm = 3, bool expectedOutOfRangeException = fal
 
             if (!succeeded)
             {
-                Succeeded = false;
-
                 TestLibrary.TestFramework.LogInformation($"Vector256<Int64.GetElement({imm}): {nameof(RunBasicScenario)} failed to throw ArgumentOutOfRangeException.");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
 
             succeeded = !expectedOutOfRangeException;
@@ -96,10 +96,10 @@ public void RunBasicScenario(int imm = 3, bool expectedOutOfRangeException = fal
 
             if (!succeeded)
             {
-                Succeeded = false;
-
                 TestLibrary.TestFramework.LogInformation($"Vector256<Int64.WithElement({imm}): {nameof(RunBasicScenario)} failed to throw ArgumentOutOfRangeException.");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
 
@@ -133,10 +133,10 @@ public void RunReflectionScenario(int imm = 3, bool expectedOutOfRangeException
 
             if (!succeeded)
             {
-                Succeeded = false;
-
                 TestLibrary.TestFramework.LogInformation($"Vector256<Int64.GetElement({imm}): {nameof(RunReflectionScenario)} failed to throw ArgumentOutOfRangeException.");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
 
             succeeded = !expectedOutOfRangeException;
@@ -158,10 +158,10 @@ public void RunReflectionScenario(int imm = 3, bool expectedOutOfRangeException
 
             if (!succeeded)
             {
-                Succeeded = false;
-
                 TestLibrary.TestFramework.LogInformation($"Vector256<Int64.WithElement({imm}): {nameof(RunReflectionScenario)} failed to throw ArgumentOutOfRangeException.");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
 
@@ -196,27 +196,31 @@ private void ValidateWithResult(Vector256<Int64> result, Int64[] values, Int64 i
 
         private void ValidateWithResult(Int64[] result, Int64[] values, Int64 insertedValue, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             for (int i = 0; i < ElementCount; i++)
             {
                 if ((i != 3) && (result[i] != values[i]))
                 {
-                    Succeeded = false;
+                    succeeded = false;
                     break;
                 }
             }
 
             if (result[3] != insertedValue)
             {
-                Succeeded = false;
+                succeeded = false;
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"Vector256<Int64.WithElement(3): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"   value: ({string.Join(", ", values)})");
                 TestLibrary.TestFramework.LogInformation($"  insert: insertedValue");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/General/Vector256_1/GetAndWithElement.SByte.0.cs b/tests/src/JIT/HardwareIntrinsics/General/Vector256_1/GetAndWithElement.SByte.0.cs
index dd08864f2ebd..8bbb4fb9facb 100644
--- a/tests/src/JIT/HardwareIntrinsics/General/Vector256_1/GetAndWithElement.SByte.0.cs
+++ b/tests/src/JIT/HardwareIntrinsics/General/Vector256_1/GetAndWithElement.SByte.0.cs
@@ -74,10 +74,10 @@ public void RunBasicScenario(int imm = 0, bool expectedOutOfRangeException = fal
 
             if (!succeeded)
             {
-                Succeeded = false;
-
                 TestLibrary.TestFramework.LogInformation($"Vector256<SByte.GetElement({imm}): {nameof(RunBasicScenario)} failed to throw ArgumentOutOfRangeException.");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
 
             succeeded = !expectedOutOfRangeException;
@@ -96,10 +96,10 @@ public void RunBasicScenario(int imm = 0, bool expectedOutOfRangeException = fal
 
             if (!succeeded)
             {
-                Succeeded = false;
-
                 TestLibrary.TestFramework.LogInformation($"Vector256<SByte.WithElement({imm}): {nameof(RunBasicScenario)} failed to throw ArgumentOutOfRangeException.");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
 
@@ -133,10 +133,10 @@ public void RunReflectionScenario(int imm = 0, bool expectedOutOfRangeException
 
             if (!succeeded)
             {
-                Succeeded = false;
-
                 TestLibrary.TestFramework.LogInformation($"Vector256<SByte.GetElement({imm}): {nameof(RunReflectionScenario)} failed to throw ArgumentOutOfRangeException.");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
 
             succeeded = !expectedOutOfRangeException;
@@ -158,10 +158,10 @@ public void RunReflectionScenario(int imm = 0, bool expectedOutOfRangeException
 
             if (!succeeded)
             {
-                Succeeded = false;
-
                 TestLibrary.TestFramework.LogInformation($"Vector256<SByte.WithElement({imm}): {nameof(RunReflectionScenario)} failed to throw ArgumentOutOfRangeException.");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
 
@@ -196,27 +196,31 @@ private void ValidateWithResult(Vector256<SByte> result, SByte[] values, SByte i
 
         private void ValidateWithResult(SByte[] result, SByte[] values, SByte insertedValue, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             for (int i = 0; i < ElementCount; i++)
             {
                 if ((i != 0) && (result[i] != values[i]))
                 {
-                    Succeeded = false;
+                    succeeded = false;
                     break;
                 }
             }
 
             if (result[0] != insertedValue)
             {
-                Succeeded = false;
+                succeeded = false;
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"Vector256<SByte.WithElement(0): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"   value: ({string.Join(", ", values)})");
                 TestLibrary.TestFramework.LogInformation($"  insert: insertedValue");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/General/Vector256_1/GetAndWithElement.SByte.15.cs b/tests/src/JIT/HardwareIntrinsics/General/Vector256_1/GetAndWithElement.SByte.15.cs
index 8a0dcc179c22..f45692205958 100644
--- a/tests/src/JIT/HardwareIntrinsics/General/Vector256_1/GetAndWithElement.SByte.15.cs
+++ b/tests/src/JIT/HardwareIntrinsics/General/Vector256_1/GetAndWithElement.SByte.15.cs
@@ -74,10 +74,10 @@ public void RunBasicScenario(int imm = 15, bool expectedOutOfRangeException = fa
 
             if (!succeeded)
             {
-                Succeeded = false;
-
                 TestLibrary.TestFramework.LogInformation($"Vector256<SByte.GetElement({imm}): {nameof(RunBasicScenario)} failed to throw ArgumentOutOfRangeException.");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
 
             succeeded = !expectedOutOfRangeException;
@@ -96,10 +96,10 @@ public void RunBasicScenario(int imm = 15, bool expectedOutOfRangeException = fa
 
             if (!succeeded)
             {
-                Succeeded = false;
-
                 TestLibrary.TestFramework.LogInformation($"Vector256<SByte.WithElement({imm}): {nameof(RunBasicScenario)} failed to throw ArgumentOutOfRangeException.");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
 
@@ -133,10 +133,10 @@ public void RunReflectionScenario(int imm = 15, bool expectedOutOfRangeException
 
             if (!succeeded)
             {
-                Succeeded = false;
-
                 TestLibrary.TestFramework.LogInformation($"Vector256<SByte.GetElement({imm}): {nameof(RunReflectionScenario)} failed to throw ArgumentOutOfRangeException.");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
 
             succeeded = !expectedOutOfRangeException;
@@ -158,10 +158,10 @@ public void RunReflectionScenario(int imm = 15, bool expectedOutOfRangeException
 
             if (!succeeded)
             {
-                Succeeded = false;
-
                 TestLibrary.TestFramework.LogInformation($"Vector256<SByte.WithElement({imm}): {nameof(RunReflectionScenario)} failed to throw ArgumentOutOfRangeException.");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
 
@@ -196,27 +196,31 @@ private void ValidateWithResult(Vector256<SByte> result, SByte[] values, SByte i
 
         private void ValidateWithResult(SByte[] result, SByte[] values, SByte insertedValue, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             for (int i = 0; i < ElementCount; i++)
             {
                 if ((i != 15) && (result[i] != values[i]))
                 {
-                    Succeeded = false;
+                    succeeded = false;
                     break;
                 }
             }
 
             if (result[15] != insertedValue)
             {
-                Succeeded = false;
+                succeeded = false;
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"Vector256<SByte.WithElement(15): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"   value: ({string.Join(", ", values)})");
                 TestLibrary.TestFramework.LogInformation($"  insert: insertedValue");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/General/Vector256_1/GetAndWithElement.SByte.31.cs b/tests/src/JIT/HardwareIntrinsics/General/Vector256_1/GetAndWithElement.SByte.31.cs
index 7e23c46d77da..ac318cf84111 100644
--- a/tests/src/JIT/HardwareIntrinsics/General/Vector256_1/GetAndWithElement.SByte.31.cs
+++ b/tests/src/JIT/HardwareIntrinsics/General/Vector256_1/GetAndWithElement.SByte.31.cs
@@ -74,10 +74,10 @@ public void RunBasicScenario(int imm = 31, bool expectedOutOfRangeException = fa
 
             if (!succeeded)
             {
-                Succeeded = false;
-
                 TestLibrary.TestFramework.LogInformation($"Vector256<SByte.GetElement({imm}): {nameof(RunBasicScenario)} failed to throw ArgumentOutOfRangeException.");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
 
             succeeded = !expectedOutOfRangeException;
@@ -96,10 +96,10 @@ public void RunBasicScenario(int imm = 31, bool expectedOutOfRangeException = fa
 
             if (!succeeded)
             {
-                Succeeded = false;
-
                 TestLibrary.TestFramework.LogInformation($"Vector256<SByte.WithElement({imm}): {nameof(RunBasicScenario)} failed to throw ArgumentOutOfRangeException.");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
 
@@ -133,10 +133,10 @@ public void RunReflectionScenario(int imm = 31, bool expectedOutOfRangeException
 
             if (!succeeded)
             {
-                Succeeded = false;
-
                 TestLibrary.TestFramework.LogInformation($"Vector256<SByte.GetElement({imm}): {nameof(RunReflectionScenario)} failed to throw ArgumentOutOfRangeException.");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
 
             succeeded = !expectedOutOfRangeException;
@@ -158,10 +158,10 @@ public void RunReflectionScenario(int imm = 31, bool expectedOutOfRangeException
 
             if (!succeeded)
             {
-                Succeeded = false;
-
                 TestLibrary.TestFramework.LogInformation($"Vector256<SByte.WithElement({imm}): {nameof(RunReflectionScenario)} failed to throw ArgumentOutOfRangeException.");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
 
@@ -196,27 +196,31 @@ private void ValidateWithResult(Vector256<SByte> result, SByte[] values, SByte i
 
         private void ValidateWithResult(SByte[] result, SByte[] values, SByte insertedValue, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             for (int i = 0; i < ElementCount; i++)
             {
                 if ((i != 31) && (result[i] != values[i]))
                 {
-                    Succeeded = false;
+                    succeeded = false;
                     break;
                 }
             }
 
             if (result[31] != insertedValue)
             {
-                Succeeded = false;
+                succeeded = false;
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"Vector256<SByte.WithElement(31): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"   value: ({string.Join(", ", values)})");
                 TestLibrary.TestFramework.LogInformation($"  insert: insertedValue");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/General/Vector256_1/GetAndWithElement.SByte.7.cs b/tests/src/JIT/HardwareIntrinsics/General/Vector256_1/GetAndWithElement.SByte.7.cs
index 6db1ea6d11be..5fbb471e11ee 100644
--- a/tests/src/JIT/HardwareIntrinsics/General/Vector256_1/GetAndWithElement.SByte.7.cs
+++ b/tests/src/JIT/HardwareIntrinsics/General/Vector256_1/GetAndWithElement.SByte.7.cs
@@ -74,10 +74,10 @@ public void RunBasicScenario(int imm = 7, bool expectedOutOfRangeException = fal
 
             if (!succeeded)
             {
-                Succeeded = false;
-
                 TestLibrary.TestFramework.LogInformation($"Vector256<SByte.GetElement({imm}): {nameof(RunBasicScenario)} failed to throw ArgumentOutOfRangeException.");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
 
             succeeded = !expectedOutOfRangeException;
@@ -96,10 +96,10 @@ public void RunBasicScenario(int imm = 7, bool expectedOutOfRangeException = fal
 
             if (!succeeded)
             {
-                Succeeded = false;
-
                 TestLibrary.TestFramework.LogInformation($"Vector256<SByte.WithElement({imm}): {nameof(RunBasicScenario)} failed to throw ArgumentOutOfRangeException.");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
 
@@ -133,10 +133,10 @@ public void RunReflectionScenario(int imm = 7, bool expectedOutOfRangeException
 
             if (!succeeded)
             {
-                Succeeded = false;
-
                 TestLibrary.TestFramework.LogInformation($"Vector256<SByte.GetElement({imm}): {nameof(RunReflectionScenario)} failed to throw ArgumentOutOfRangeException.");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
 
             succeeded = !expectedOutOfRangeException;
@@ -158,10 +158,10 @@ public void RunReflectionScenario(int imm = 7, bool expectedOutOfRangeException
 
             if (!succeeded)
             {
-                Succeeded = false;
-
                 TestLibrary.TestFramework.LogInformation($"Vector256<SByte.WithElement({imm}): {nameof(RunReflectionScenario)} failed to throw ArgumentOutOfRangeException.");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
 
@@ -196,27 +196,31 @@ private void ValidateWithResult(Vector256<SByte> result, SByte[] values, SByte i
 
         private void ValidateWithResult(SByte[] result, SByte[] values, SByte insertedValue, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             for (int i = 0; i < ElementCount; i++)
             {
                 if ((i != 7) && (result[i] != values[i]))
                 {
-                    Succeeded = false;
+                    succeeded = false;
                     break;
                 }
             }
 
             if (result[7] != insertedValue)
             {
-                Succeeded = false;
+                succeeded = false;
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"Vector256<SByte.WithElement(7): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"   value: ({string.Join(", ", values)})");
                 TestLibrary.TestFramework.LogInformation($"  insert: insertedValue");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/General/Vector256_1/GetAndWithElement.Single.0.cs b/tests/src/JIT/HardwareIntrinsics/General/Vector256_1/GetAndWithElement.Single.0.cs
index 510ffa871dbd..c0fb38f12ed4 100644
--- a/tests/src/JIT/HardwareIntrinsics/General/Vector256_1/GetAndWithElement.Single.0.cs
+++ b/tests/src/JIT/HardwareIntrinsics/General/Vector256_1/GetAndWithElement.Single.0.cs
@@ -74,10 +74,10 @@ public void RunBasicScenario(int imm = 0, bool expectedOutOfRangeException = fal
 
             if (!succeeded)
             {
-                Succeeded = false;
-
                 TestLibrary.TestFramework.LogInformation($"Vector256<Single.GetElement({imm}): {nameof(RunBasicScenario)} failed to throw ArgumentOutOfRangeException.");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
 
             succeeded = !expectedOutOfRangeException;
@@ -96,10 +96,10 @@ public void RunBasicScenario(int imm = 0, bool expectedOutOfRangeException = fal
 
             if (!succeeded)
             {
-                Succeeded = false;
-
                 TestLibrary.TestFramework.LogInformation($"Vector256<Single.WithElement({imm}): {nameof(RunBasicScenario)} failed to throw ArgumentOutOfRangeException.");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
 
@@ -133,10 +133,10 @@ public void RunReflectionScenario(int imm = 0, bool expectedOutOfRangeException
 
             if (!succeeded)
             {
-                Succeeded = false;
-
                 TestLibrary.TestFramework.LogInformation($"Vector256<Single.GetElement({imm}): {nameof(RunReflectionScenario)} failed to throw ArgumentOutOfRangeException.");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
 
             succeeded = !expectedOutOfRangeException;
@@ -158,10 +158,10 @@ public void RunReflectionScenario(int imm = 0, bool expectedOutOfRangeException
 
             if (!succeeded)
             {
-                Succeeded = false;
-
                 TestLibrary.TestFramework.LogInformation($"Vector256<Single.WithElement({imm}): {nameof(RunReflectionScenario)} failed to throw ArgumentOutOfRangeException.");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
 
@@ -196,27 +196,31 @@ private void ValidateWithResult(Vector256<Single> result, Single[] values, Singl
 
         private void ValidateWithResult(Single[] result, Single[] values, Single insertedValue, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             for (int i = 0; i < ElementCount; i++)
             {
                 if ((i != 0) && (result[i] != values[i]))
                 {
-                    Succeeded = false;
+                    succeeded = false;
                     break;
                 }
             }
 
             if (result[0] != insertedValue)
             {
-                Succeeded = false;
+                succeeded = false;
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"Vector256<Single.WithElement(0): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"   value: ({string.Join(", ", values)})");
                 TestLibrary.TestFramework.LogInformation($"  insert: insertedValue");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/General/Vector256_1/GetAndWithElement.Single.1.cs b/tests/src/JIT/HardwareIntrinsics/General/Vector256_1/GetAndWithElement.Single.1.cs
index 483f1e04cc44..b1f7ccf511d9 100644
--- a/tests/src/JIT/HardwareIntrinsics/General/Vector256_1/GetAndWithElement.Single.1.cs
+++ b/tests/src/JIT/HardwareIntrinsics/General/Vector256_1/GetAndWithElement.Single.1.cs
@@ -74,10 +74,10 @@ public void RunBasicScenario(int imm = 1, bool expectedOutOfRangeException = fal
 
             if (!succeeded)
             {
-                Succeeded = false;
-
                 TestLibrary.TestFramework.LogInformation($"Vector256<Single.GetElement({imm}): {nameof(RunBasicScenario)} failed to throw ArgumentOutOfRangeException.");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
 
             succeeded = !expectedOutOfRangeException;
@@ -96,10 +96,10 @@ public void RunBasicScenario(int imm = 1, bool expectedOutOfRangeException = fal
 
             if (!succeeded)
             {
-                Succeeded = false;
-
                 TestLibrary.TestFramework.LogInformation($"Vector256<Single.WithElement({imm}): {nameof(RunBasicScenario)} failed to throw ArgumentOutOfRangeException.");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
 
@@ -133,10 +133,10 @@ public void RunReflectionScenario(int imm = 1, bool expectedOutOfRangeException
 
             if (!succeeded)
             {
-                Succeeded = false;
-
                 TestLibrary.TestFramework.LogInformation($"Vector256<Single.GetElement({imm}): {nameof(RunReflectionScenario)} failed to throw ArgumentOutOfRangeException.");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
 
             succeeded = !expectedOutOfRangeException;
@@ -158,10 +158,10 @@ public void RunReflectionScenario(int imm = 1, bool expectedOutOfRangeException
 
             if (!succeeded)
             {
-                Succeeded = false;
-
                 TestLibrary.TestFramework.LogInformation($"Vector256<Single.WithElement({imm}): {nameof(RunReflectionScenario)} failed to throw ArgumentOutOfRangeException.");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
 
@@ -196,27 +196,31 @@ private void ValidateWithResult(Vector256<Single> result, Single[] values, Singl
 
         private void ValidateWithResult(Single[] result, Single[] values, Single insertedValue, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             for (int i = 0; i < ElementCount; i++)
             {
                 if ((i != 1) && (result[i] != values[i]))
                 {
-                    Succeeded = false;
+                    succeeded = false;
                     break;
                 }
             }
 
             if (result[1] != insertedValue)
             {
-                Succeeded = false;
+                succeeded = false;
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"Vector256<Single.WithElement(1): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"   value: ({string.Join(", ", values)})");
                 TestLibrary.TestFramework.LogInformation($"  insert: insertedValue");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/General/Vector256_1/GetAndWithElement.Single.3.cs b/tests/src/JIT/HardwareIntrinsics/General/Vector256_1/GetAndWithElement.Single.3.cs
index 18e1b9bba244..8515ec9a0df1 100644
--- a/tests/src/JIT/HardwareIntrinsics/General/Vector256_1/GetAndWithElement.Single.3.cs
+++ b/tests/src/JIT/HardwareIntrinsics/General/Vector256_1/GetAndWithElement.Single.3.cs
@@ -74,10 +74,10 @@ public void RunBasicScenario(int imm = 3, bool expectedOutOfRangeException = fal
 
             if (!succeeded)
             {
-                Succeeded = false;
-
                 TestLibrary.TestFramework.LogInformation($"Vector256<Single.GetElement({imm}): {nameof(RunBasicScenario)} failed to throw ArgumentOutOfRangeException.");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
 
             succeeded = !expectedOutOfRangeException;
@@ -96,10 +96,10 @@ public void RunBasicScenario(int imm = 3, bool expectedOutOfRangeException = fal
 
             if (!succeeded)
             {
-                Succeeded = false;
-
                 TestLibrary.TestFramework.LogInformation($"Vector256<Single.WithElement({imm}): {nameof(RunBasicScenario)} failed to throw ArgumentOutOfRangeException.");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
 
@@ -133,10 +133,10 @@ public void RunReflectionScenario(int imm = 3, bool expectedOutOfRangeException
 
             if (!succeeded)
             {
-                Succeeded = false;
-
                 TestLibrary.TestFramework.LogInformation($"Vector256<Single.GetElement({imm}): {nameof(RunReflectionScenario)} failed to throw ArgumentOutOfRangeException.");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
 
             succeeded = !expectedOutOfRangeException;
@@ -158,10 +158,10 @@ public void RunReflectionScenario(int imm = 3, bool expectedOutOfRangeException
 
             if (!succeeded)
             {
-                Succeeded = false;
-
                 TestLibrary.TestFramework.LogInformation($"Vector256<Single.WithElement({imm}): {nameof(RunReflectionScenario)} failed to throw ArgumentOutOfRangeException.");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
 
@@ -196,27 +196,31 @@ private void ValidateWithResult(Vector256<Single> result, Single[] values, Singl
 
         private void ValidateWithResult(Single[] result, Single[] values, Single insertedValue, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             for (int i = 0; i < ElementCount; i++)
             {
                 if ((i != 3) && (result[i] != values[i]))
                 {
-                    Succeeded = false;
+                    succeeded = false;
                     break;
                 }
             }
 
             if (result[3] != insertedValue)
             {
-                Succeeded = false;
+                succeeded = false;
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"Vector256<Single.WithElement(3): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"   value: ({string.Join(", ", values)})");
                 TestLibrary.TestFramework.LogInformation($"  insert: insertedValue");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/General/Vector256_1/GetAndWithElement.Single.7.cs b/tests/src/JIT/HardwareIntrinsics/General/Vector256_1/GetAndWithElement.Single.7.cs
index 4f98f05166e9..9398f220fc75 100644
--- a/tests/src/JIT/HardwareIntrinsics/General/Vector256_1/GetAndWithElement.Single.7.cs
+++ b/tests/src/JIT/HardwareIntrinsics/General/Vector256_1/GetAndWithElement.Single.7.cs
@@ -74,10 +74,10 @@ public void RunBasicScenario(int imm = 7, bool expectedOutOfRangeException = fal
 
             if (!succeeded)
             {
-                Succeeded = false;
-
                 TestLibrary.TestFramework.LogInformation($"Vector256<Single.GetElement({imm}): {nameof(RunBasicScenario)} failed to throw ArgumentOutOfRangeException.");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
 
             succeeded = !expectedOutOfRangeException;
@@ -96,10 +96,10 @@ public void RunBasicScenario(int imm = 7, bool expectedOutOfRangeException = fal
 
             if (!succeeded)
             {
-                Succeeded = false;
-
                 TestLibrary.TestFramework.LogInformation($"Vector256<Single.WithElement({imm}): {nameof(RunBasicScenario)} failed to throw ArgumentOutOfRangeException.");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
 
@@ -133,10 +133,10 @@ public void RunReflectionScenario(int imm = 7, bool expectedOutOfRangeException
 
             if (!succeeded)
             {
-                Succeeded = false;
-
                 TestLibrary.TestFramework.LogInformation($"Vector256<Single.GetElement({imm}): {nameof(RunReflectionScenario)} failed to throw ArgumentOutOfRangeException.");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
 
             succeeded = !expectedOutOfRangeException;
@@ -158,10 +158,10 @@ public void RunReflectionScenario(int imm = 7, bool expectedOutOfRangeException
 
             if (!succeeded)
             {
-                Succeeded = false;
-
                 TestLibrary.TestFramework.LogInformation($"Vector256<Single.WithElement({imm}): {nameof(RunReflectionScenario)} failed to throw ArgumentOutOfRangeException.");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
 
@@ -196,27 +196,31 @@ private void ValidateWithResult(Vector256<Single> result, Single[] values, Singl
 
         private void ValidateWithResult(Single[] result, Single[] values, Single insertedValue, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             for (int i = 0; i < ElementCount; i++)
             {
                 if ((i != 7) && (result[i] != values[i]))
                 {
-                    Succeeded = false;
+                    succeeded = false;
                     break;
                 }
             }
 
             if (result[7] != insertedValue)
             {
-                Succeeded = false;
+                succeeded = false;
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"Vector256<Single.WithElement(7): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"   value: ({string.Join(", ", values)})");
                 TestLibrary.TestFramework.LogInformation($"  insert: insertedValue");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/General/Vector256_1/GetAndWithElement.UInt16.0.cs b/tests/src/JIT/HardwareIntrinsics/General/Vector256_1/GetAndWithElement.UInt16.0.cs
index 9c6aaeef8758..ebe1836f5172 100644
--- a/tests/src/JIT/HardwareIntrinsics/General/Vector256_1/GetAndWithElement.UInt16.0.cs
+++ b/tests/src/JIT/HardwareIntrinsics/General/Vector256_1/GetAndWithElement.UInt16.0.cs
@@ -74,10 +74,10 @@ public void RunBasicScenario(int imm = 0, bool expectedOutOfRangeException = fal
 
             if (!succeeded)
             {
-                Succeeded = false;
-
                 TestLibrary.TestFramework.LogInformation($"Vector256<UInt16.GetElement({imm}): {nameof(RunBasicScenario)} failed to throw ArgumentOutOfRangeException.");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
 
             succeeded = !expectedOutOfRangeException;
@@ -96,10 +96,10 @@ public void RunBasicScenario(int imm = 0, bool expectedOutOfRangeException = fal
 
             if (!succeeded)
             {
-                Succeeded = false;
-
                 TestLibrary.TestFramework.LogInformation($"Vector256<UInt16.WithElement({imm}): {nameof(RunBasicScenario)} failed to throw ArgumentOutOfRangeException.");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
 
@@ -133,10 +133,10 @@ public void RunReflectionScenario(int imm = 0, bool expectedOutOfRangeException
 
             if (!succeeded)
             {
-                Succeeded = false;
-
                 TestLibrary.TestFramework.LogInformation($"Vector256<UInt16.GetElement({imm}): {nameof(RunReflectionScenario)} failed to throw ArgumentOutOfRangeException.");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
 
             succeeded = !expectedOutOfRangeException;
@@ -158,10 +158,10 @@ public void RunReflectionScenario(int imm = 0, bool expectedOutOfRangeException
 
             if (!succeeded)
             {
-                Succeeded = false;
-
                 TestLibrary.TestFramework.LogInformation($"Vector256<UInt16.WithElement({imm}): {nameof(RunReflectionScenario)} failed to throw ArgumentOutOfRangeException.");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
 
@@ -196,27 +196,31 @@ private void ValidateWithResult(Vector256<UInt16> result, UInt16[] values, UInt1
 
         private void ValidateWithResult(UInt16[] result, UInt16[] values, UInt16 insertedValue, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             for (int i = 0; i < ElementCount; i++)
             {
                 if ((i != 0) && (result[i] != values[i]))
                 {
-                    Succeeded = false;
+                    succeeded = false;
                     break;
                 }
             }
 
             if (result[0] != insertedValue)
             {
-                Succeeded = false;
+                succeeded = false;
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"Vector256<UInt16.WithElement(0): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"   value: ({string.Join(", ", values)})");
                 TestLibrary.TestFramework.LogInformation($"  insert: insertedValue");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/General/Vector256_1/GetAndWithElement.UInt16.15.cs b/tests/src/JIT/HardwareIntrinsics/General/Vector256_1/GetAndWithElement.UInt16.15.cs
index 7676cb733c5e..fa7576e42da5 100644
--- a/tests/src/JIT/HardwareIntrinsics/General/Vector256_1/GetAndWithElement.UInt16.15.cs
+++ b/tests/src/JIT/HardwareIntrinsics/General/Vector256_1/GetAndWithElement.UInt16.15.cs
@@ -74,10 +74,10 @@ public void RunBasicScenario(int imm = 15, bool expectedOutOfRangeException = fa
 
             if (!succeeded)
             {
-                Succeeded = false;
-
                 TestLibrary.TestFramework.LogInformation($"Vector256<UInt16.GetElement({imm}): {nameof(RunBasicScenario)} failed to throw ArgumentOutOfRangeException.");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
 
             succeeded = !expectedOutOfRangeException;
@@ -96,10 +96,10 @@ public void RunBasicScenario(int imm = 15, bool expectedOutOfRangeException = fa
 
             if (!succeeded)
             {
-                Succeeded = false;
-
                 TestLibrary.TestFramework.LogInformation($"Vector256<UInt16.WithElement({imm}): {nameof(RunBasicScenario)} failed to throw ArgumentOutOfRangeException.");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
 
@@ -133,10 +133,10 @@ public void RunReflectionScenario(int imm = 15, bool expectedOutOfRangeException
 
             if (!succeeded)
             {
-                Succeeded = false;
-
                 TestLibrary.TestFramework.LogInformation($"Vector256<UInt16.GetElement({imm}): {nameof(RunReflectionScenario)} failed to throw ArgumentOutOfRangeException.");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
 
             succeeded = !expectedOutOfRangeException;
@@ -158,10 +158,10 @@ public void RunReflectionScenario(int imm = 15, bool expectedOutOfRangeException
 
             if (!succeeded)
             {
-                Succeeded = false;
-
                 TestLibrary.TestFramework.LogInformation($"Vector256<UInt16.WithElement({imm}): {nameof(RunReflectionScenario)} failed to throw ArgumentOutOfRangeException.");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
 
@@ -196,27 +196,31 @@ private void ValidateWithResult(Vector256<UInt16> result, UInt16[] values, UInt1
 
         private void ValidateWithResult(UInt16[] result, UInt16[] values, UInt16 insertedValue, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             for (int i = 0; i < ElementCount; i++)
             {
                 if ((i != 15) && (result[i] != values[i]))
                 {
-                    Succeeded = false;
+                    succeeded = false;
                     break;
                 }
             }
 
             if (result[15] != insertedValue)
             {
-                Succeeded = false;
+                succeeded = false;
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"Vector256<UInt16.WithElement(15): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"   value: ({string.Join(", ", values)})");
                 TestLibrary.TestFramework.LogInformation($"  insert: insertedValue");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/General/Vector256_1/GetAndWithElement.UInt16.3.cs b/tests/src/JIT/HardwareIntrinsics/General/Vector256_1/GetAndWithElement.UInt16.3.cs
index 319ca8ceb69e..347e21a78e0c 100644
--- a/tests/src/JIT/HardwareIntrinsics/General/Vector256_1/GetAndWithElement.UInt16.3.cs
+++ b/tests/src/JIT/HardwareIntrinsics/General/Vector256_1/GetAndWithElement.UInt16.3.cs
@@ -74,10 +74,10 @@ public void RunBasicScenario(int imm = 3, bool expectedOutOfRangeException = fal
 
             if (!succeeded)
             {
-                Succeeded = false;
-
                 TestLibrary.TestFramework.LogInformation($"Vector256<UInt16.GetElement({imm}): {nameof(RunBasicScenario)} failed to throw ArgumentOutOfRangeException.");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
 
             succeeded = !expectedOutOfRangeException;
@@ -96,10 +96,10 @@ public void RunBasicScenario(int imm = 3, bool expectedOutOfRangeException = fal
 
             if (!succeeded)
             {
-                Succeeded = false;
-
                 TestLibrary.TestFramework.LogInformation($"Vector256<UInt16.WithElement({imm}): {nameof(RunBasicScenario)} failed to throw ArgumentOutOfRangeException.");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
 
@@ -133,10 +133,10 @@ public void RunReflectionScenario(int imm = 3, bool expectedOutOfRangeException
 
             if (!succeeded)
             {
-                Succeeded = false;
-
                 TestLibrary.TestFramework.LogInformation($"Vector256<UInt16.GetElement({imm}): {nameof(RunReflectionScenario)} failed to throw ArgumentOutOfRangeException.");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
 
             succeeded = !expectedOutOfRangeException;
@@ -158,10 +158,10 @@ public void RunReflectionScenario(int imm = 3, bool expectedOutOfRangeException
 
             if (!succeeded)
             {
-                Succeeded = false;
-
                 TestLibrary.TestFramework.LogInformation($"Vector256<UInt16.WithElement({imm}): {nameof(RunReflectionScenario)} failed to throw ArgumentOutOfRangeException.");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
 
@@ -196,27 +196,31 @@ private void ValidateWithResult(Vector256<UInt16> result, UInt16[] values, UInt1
 
         private void ValidateWithResult(UInt16[] result, UInt16[] values, UInt16 insertedValue, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             for (int i = 0; i < ElementCount; i++)
             {
                 if ((i != 3) && (result[i] != values[i]))
                 {
-                    Succeeded = false;
+                    succeeded = false;
                     break;
                 }
             }
 
             if (result[3] != insertedValue)
             {
-                Succeeded = false;
+                succeeded = false;
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"Vector256<UInt16.WithElement(3): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"   value: ({string.Join(", ", values)})");
                 TestLibrary.TestFramework.LogInformation($"  insert: insertedValue");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/General/Vector256_1/GetAndWithElement.UInt16.7.cs b/tests/src/JIT/HardwareIntrinsics/General/Vector256_1/GetAndWithElement.UInt16.7.cs
index b176d0dca798..24ef80c05361 100644
--- a/tests/src/JIT/HardwareIntrinsics/General/Vector256_1/GetAndWithElement.UInt16.7.cs
+++ b/tests/src/JIT/HardwareIntrinsics/General/Vector256_1/GetAndWithElement.UInt16.7.cs
@@ -74,10 +74,10 @@ public void RunBasicScenario(int imm = 7, bool expectedOutOfRangeException = fal
 
             if (!succeeded)
             {
-                Succeeded = false;
-
                 TestLibrary.TestFramework.LogInformation($"Vector256<UInt16.GetElement({imm}): {nameof(RunBasicScenario)} failed to throw ArgumentOutOfRangeException.");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
 
             succeeded = !expectedOutOfRangeException;
@@ -96,10 +96,10 @@ public void RunBasicScenario(int imm = 7, bool expectedOutOfRangeException = fal
 
             if (!succeeded)
             {
-                Succeeded = false;
-
                 TestLibrary.TestFramework.LogInformation($"Vector256<UInt16.WithElement({imm}): {nameof(RunBasicScenario)} failed to throw ArgumentOutOfRangeException.");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
 
@@ -133,10 +133,10 @@ public void RunReflectionScenario(int imm = 7, bool expectedOutOfRangeException
 
             if (!succeeded)
             {
-                Succeeded = false;
-
                 TestLibrary.TestFramework.LogInformation($"Vector256<UInt16.GetElement({imm}): {nameof(RunReflectionScenario)} failed to throw ArgumentOutOfRangeException.");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
 
             succeeded = !expectedOutOfRangeException;
@@ -158,10 +158,10 @@ public void RunReflectionScenario(int imm = 7, bool expectedOutOfRangeException
 
             if (!succeeded)
             {
-                Succeeded = false;
-
                 TestLibrary.TestFramework.LogInformation($"Vector256<UInt16.WithElement({imm}): {nameof(RunReflectionScenario)} failed to throw ArgumentOutOfRangeException.");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
 
@@ -196,27 +196,31 @@ private void ValidateWithResult(Vector256<UInt16> result, UInt16[] values, UInt1
 
         private void ValidateWithResult(UInt16[] result, UInt16[] values, UInt16 insertedValue, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             for (int i = 0; i < ElementCount; i++)
             {
                 if ((i != 7) && (result[i] != values[i]))
                 {
-                    Succeeded = false;
+                    succeeded = false;
                     break;
                 }
             }
 
             if (result[7] != insertedValue)
             {
-                Succeeded = false;
+                succeeded = false;
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"Vector256<UInt16.WithElement(7): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"   value: ({string.Join(", ", values)})");
                 TestLibrary.TestFramework.LogInformation($"  insert: insertedValue");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/General/Vector256_1/GetAndWithElement.UInt32.0.cs b/tests/src/JIT/HardwareIntrinsics/General/Vector256_1/GetAndWithElement.UInt32.0.cs
index f2b264a6bc7d..08bc2a1e7029 100644
--- a/tests/src/JIT/HardwareIntrinsics/General/Vector256_1/GetAndWithElement.UInt32.0.cs
+++ b/tests/src/JIT/HardwareIntrinsics/General/Vector256_1/GetAndWithElement.UInt32.0.cs
@@ -74,10 +74,10 @@ public void RunBasicScenario(int imm = 0, bool expectedOutOfRangeException = fal
 
             if (!succeeded)
             {
-                Succeeded = false;
-
                 TestLibrary.TestFramework.LogInformation($"Vector256<UInt32.GetElement({imm}): {nameof(RunBasicScenario)} failed to throw ArgumentOutOfRangeException.");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
 
             succeeded = !expectedOutOfRangeException;
@@ -96,10 +96,10 @@ public void RunBasicScenario(int imm = 0, bool expectedOutOfRangeException = fal
 
             if (!succeeded)
             {
-                Succeeded = false;
-
                 TestLibrary.TestFramework.LogInformation($"Vector256<UInt32.WithElement({imm}): {nameof(RunBasicScenario)} failed to throw ArgumentOutOfRangeException.");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
 
@@ -133,10 +133,10 @@ public void RunReflectionScenario(int imm = 0, bool expectedOutOfRangeException
 
             if (!succeeded)
             {
-                Succeeded = false;
-
                 TestLibrary.TestFramework.LogInformation($"Vector256<UInt32.GetElement({imm}): {nameof(RunReflectionScenario)} failed to throw ArgumentOutOfRangeException.");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
 
             succeeded = !expectedOutOfRangeException;
@@ -158,10 +158,10 @@ public void RunReflectionScenario(int imm = 0, bool expectedOutOfRangeException
 
             if (!succeeded)
             {
-                Succeeded = false;
-
                 TestLibrary.TestFramework.LogInformation($"Vector256<UInt32.WithElement({imm}): {nameof(RunReflectionScenario)} failed to throw ArgumentOutOfRangeException.");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
 
@@ -196,27 +196,31 @@ private void ValidateWithResult(Vector256<UInt32> result, UInt32[] values, UInt3
 
         private void ValidateWithResult(UInt32[] result, UInt32[] values, UInt32 insertedValue, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             for (int i = 0; i < ElementCount; i++)
             {
                 if ((i != 0) && (result[i] != values[i]))
                 {
-                    Succeeded = false;
+                    succeeded = false;
                     break;
                 }
             }
 
             if (result[0] != insertedValue)
             {
-                Succeeded = false;
+                succeeded = false;
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"Vector256<UInt32.WithElement(0): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"   value: ({string.Join(", ", values)})");
                 TestLibrary.TestFramework.LogInformation($"  insert: insertedValue");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/General/Vector256_1/GetAndWithElement.UInt32.1.cs b/tests/src/JIT/HardwareIntrinsics/General/Vector256_1/GetAndWithElement.UInt32.1.cs
index 83b988c46eb6..ae983fdafdf5 100644
--- a/tests/src/JIT/HardwareIntrinsics/General/Vector256_1/GetAndWithElement.UInt32.1.cs
+++ b/tests/src/JIT/HardwareIntrinsics/General/Vector256_1/GetAndWithElement.UInt32.1.cs
@@ -74,10 +74,10 @@ public void RunBasicScenario(int imm = 1, bool expectedOutOfRangeException = fal
 
             if (!succeeded)
             {
-                Succeeded = false;
-
                 TestLibrary.TestFramework.LogInformation($"Vector256<UInt32.GetElement({imm}): {nameof(RunBasicScenario)} failed to throw ArgumentOutOfRangeException.");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
 
             succeeded = !expectedOutOfRangeException;
@@ -96,10 +96,10 @@ public void RunBasicScenario(int imm = 1, bool expectedOutOfRangeException = fal
 
             if (!succeeded)
             {
-                Succeeded = false;
-
                 TestLibrary.TestFramework.LogInformation($"Vector256<UInt32.WithElement({imm}): {nameof(RunBasicScenario)} failed to throw ArgumentOutOfRangeException.");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
 
@@ -133,10 +133,10 @@ public void RunReflectionScenario(int imm = 1, bool expectedOutOfRangeException
 
             if (!succeeded)
             {
-                Succeeded = false;
-
                 TestLibrary.TestFramework.LogInformation($"Vector256<UInt32.GetElement({imm}): {nameof(RunReflectionScenario)} failed to throw ArgumentOutOfRangeException.");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
 
             succeeded = !expectedOutOfRangeException;
@@ -158,10 +158,10 @@ public void RunReflectionScenario(int imm = 1, bool expectedOutOfRangeException
 
             if (!succeeded)
             {
-                Succeeded = false;
-
                 TestLibrary.TestFramework.LogInformation($"Vector256<UInt32.WithElement({imm}): {nameof(RunReflectionScenario)} failed to throw ArgumentOutOfRangeException.");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
 
@@ -196,27 +196,31 @@ private void ValidateWithResult(Vector256<UInt32> result, UInt32[] values, UInt3
 
         private void ValidateWithResult(UInt32[] result, UInt32[] values, UInt32 insertedValue, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             for (int i = 0; i < ElementCount; i++)
             {
                 if ((i != 1) && (result[i] != values[i]))
                 {
-                    Succeeded = false;
+                    succeeded = false;
                     break;
                 }
             }
 
             if (result[1] != insertedValue)
             {
-                Succeeded = false;
+                succeeded = false;
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"Vector256<UInt32.WithElement(1): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"   value: ({string.Join(", ", values)})");
                 TestLibrary.TestFramework.LogInformation($"  insert: insertedValue");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/General/Vector256_1/GetAndWithElement.UInt32.3.cs b/tests/src/JIT/HardwareIntrinsics/General/Vector256_1/GetAndWithElement.UInt32.3.cs
index d47e251361d0..04b471ae0026 100644
--- a/tests/src/JIT/HardwareIntrinsics/General/Vector256_1/GetAndWithElement.UInt32.3.cs
+++ b/tests/src/JIT/HardwareIntrinsics/General/Vector256_1/GetAndWithElement.UInt32.3.cs
@@ -74,10 +74,10 @@ public void RunBasicScenario(int imm = 3, bool expectedOutOfRangeException = fal
 
             if (!succeeded)
             {
-                Succeeded = false;
-
                 TestLibrary.TestFramework.LogInformation($"Vector256<UInt32.GetElement({imm}): {nameof(RunBasicScenario)} failed to throw ArgumentOutOfRangeException.");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
 
             succeeded = !expectedOutOfRangeException;
@@ -96,10 +96,10 @@ public void RunBasicScenario(int imm = 3, bool expectedOutOfRangeException = fal
 
             if (!succeeded)
             {
-                Succeeded = false;
-
                 TestLibrary.TestFramework.LogInformation($"Vector256<UInt32.WithElement({imm}): {nameof(RunBasicScenario)} failed to throw ArgumentOutOfRangeException.");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
 
@@ -133,10 +133,10 @@ public void RunReflectionScenario(int imm = 3, bool expectedOutOfRangeException
 
             if (!succeeded)
             {
-                Succeeded = false;
-
                 TestLibrary.TestFramework.LogInformation($"Vector256<UInt32.GetElement({imm}): {nameof(RunReflectionScenario)} failed to throw ArgumentOutOfRangeException.");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
 
             succeeded = !expectedOutOfRangeException;
@@ -158,10 +158,10 @@ public void RunReflectionScenario(int imm = 3, bool expectedOutOfRangeException
 
             if (!succeeded)
             {
-                Succeeded = false;
-
                 TestLibrary.TestFramework.LogInformation($"Vector256<UInt32.WithElement({imm}): {nameof(RunReflectionScenario)} failed to throw ArgumentOutOfRangeException.");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
 
@@ -196,27 +196,31 @@ private void ValidateWithResult(Vector256<UInt32> result, UInt32[] values, UInt3
 
         private void ValidateWithResult(UInt32[] result, UInt32[] values, UInt32 insertedValue, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             for (int i = 0; i < ElementCount; i++)
             {
                 if ((i != 3) && (result[i] != values[i]))
                 {
-                    Succeeded = false;
+                    succeeded = false;
                     break;
                 }
             }
 
             if (result[3] != insertedValue)
             {
-                Succeeded = false;
+                succeeded = false;
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"Vector256<UInt32.WithElement(3): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"   value: ({string.Join(", ", values)})");
                 TestLibrary.TestFramework.LogInformation($"  insert: insertedValue");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/General/Vector256_1/GetAndWithElement.UInt32.7.cs b/tests/src/JIT/HardwareIntrinsics/General/Vector256_1/GetAndWithElement.UInt32.7.cs
index 8ba9a38cf2a2..023e11ff032b 100644
--- a/tests/src/JIT/HardwareIntrinsics/General/Vector256_1/GetAndWithElement.UInt32.7.cs
+++ b/tests/src/JIT/HardwareIntrinsics/General/Vector256_1/GetAndWithElement.UInt32.7.cs
@@ -74,10 +74,10 @@ public void RunBasicScenario(int imm = 7, bool expectedOutOfRangeException = fal
 
             if (!succeeded)
             {
-                Succeeded = false;
-
                 TestLibrary.TestFramework.LogInformation($"Vector256<UInt32.GetElement({imm}): {nameof(RunBasicScenario)} failed to throw ArgumentOutOfRangeException.");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
 
             succeeded = !expectedOutOfRangeException;
@@ -96,10 +96,10 @@ public void RunBasicScenario(int imm = 7, bool expectedOutOfRangeException = fal
 
             if (!succeeded)
             {
-                Succeeded = false;
-
                 TestLibrary.TestFramework.LogInformation($"Vector256<UInt32.WithElement({imm}): {nameof(RunBasicScenario)} failed to throw ArgumentOutOfRangeException.");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
 
@@ -133,10 +133,10 @@ public void RunReflectionScenario(int imm = 7, bool expectedOutOfRangeException
 
             if (!succeeded)
             {
-                Succeeded = false;
-
                 TestLibrary.TestFramework.LogInformation($"Vector256<UInt32.GetElement({imm}): {nameof(RunReflectionScenario)} failed to throw ArgumentOutOfRangeException.");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
 
             succeeded = !expectedOutOfRangeException;
@@ -158,10 +158,10 @@ public void RunReflectionScenario(int imm = 7, bool expectedOutOfRangeException
 
             if (!succeeded)
             {
-                Succeeded = false;
-
                 TestLibrary.TestFramework.LogInformation($"Vector256<UInt32.WithElement({imm}): {nameof(RunReflectionScenario)} failed to throw ArgumentOutOfRangeException.");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
 
@@ -196,27 +196,31 @@ private void ValidateWithResult(Vector256<UInt32> result, UInt32[] values, UInt3
 
         private void ValidateWithResult(UInt32[] result, UInt32[] values, UInt32 insertedValue, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             for (int i = 0; i < ElementCount; i++)
             {
                 if ((i != 7) && (result[i] != values[i]))
                 {
-                    Succeeded = false;
+                    succeeded = false;
                     break;
                 }
             }
 
             if (result[7] != insertedValue)
             {
-                Succeeded = false;
+                succeeded = false;
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"Vector256<UInt32.WithElement(7): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"   value: ({string.Join(", ", values)})");
                 TestLibrary.TestFramework.LogInformation($"  insert: insertedValue");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/General/Vector256_1/GetAndWithElement.UInt64.0.cs b/tests/src/JIT/HardwareIntrinsics/General/Vector256_1/GetAndWithElement.UInt64.0.cs
index 5f3176d2420f..5d468dffceaa 100644
--- a/tests/src/JIT/HardwareIntrinsics/General/Vector256_1/GetAndWithElement.UInt64.0.cs
+++ b/tests/src/JIT/HardwareIntrinsics/General/Vector256_1/GetAndWithElement.UInt64.0.cs
@@ -74,10 +74,10 @@ public void RunBasicScenario(int imm = 0, bool expectedOutOfRangeException = fal
 
             if (!succeeded)
             {
-                Succeeded = false;
-
                 TestLibrary.TestFramework.LogInformation($"Vector256<UInt64.GetElement({imm}): {nameof(RunBasicScenario)} failed to throw ArgumentOutOfRangeException.");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
 
             succeeded = !expectedOutOfRangeException;
@@ -96,10 +96,10 @@ public void RunBasicScenario(int imm = 0, bool expectedOutOfRangeException = fal
 
             if (!succeeded)
             {
-                Succeeded = false;
-
                 TestLibrary.TestFramework.LogInformation($"Vector256<UInt64.WithElement({imm}): {nameof(RunBasicScenario)} failed to throw ArgumentOutOfRangeException.");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
 
@@ -133,10 +133,10 @@ public void RunReflectionScenario(int imm = 0, bool expectedOutOfRangeException
 
             if (!succeeded)
             {
-                Succeeded = false;
-
                 TestLibrary.TestFramework.LogInformation($"Vector256<UInt64.GetElement({imm}): {nameof(RunReflectionScenario)} failed to throw ArgumentOutOfRangeException.");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
 
             succeeded = !expectedOutOfRangeException;
@@ -158,10 +158,10 @@ public void RunReflectionScenario(int imm = 0, bool expectedOutOfRangeException
 
             if (!succeeded)
             {
-                Succeeded = false;
-
                 TestLibrary.TestFramework.LogInformation($"Vector256<UInt64.WithElement({imm}): {nameof(RunReflectionScenario)} failed to throw ArgumentOutOfRangeException.");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
 
@@ -196,27 +196,31 @@ private void ValidateWithResult(Vector256<UInt64> result, UInt64[] values, UInt6
 
         private void ValidateWithResult(UInt64[] result, UInt64[] values, UInt64 insertedValue, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             for (int i = 0; i < ElementCount; i++)
             {
                 if ((i != 0) && (result[i] != values[i]))
                 {
-                    Succeeded = false;
+                    succeeded = false;
                     break;
                 }
             }
 
             if (result[0] != insertedValue)
             {
-                Succeeded = false;
+                succeeded = false;
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"Vector256<UInt64.WithElement(0): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"   value: ({string.Join(", ", values)})");
                 TestLibrary.TestFramework.LogInformation($"  insert: insertedValue");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/General/Vector256_1/GetAndWithElement.UInt64.1.cs b/tests/src/JIT/HardwareIntrinsics/General/Vector256_1/GetAndWithElement.UInt64.1.cs
index cee095166381..4ecc4920ad2d 100644
--- a/tests/src/JIT/HardwareIntrinsics/General/Vector256_1/GetAndWithElement.UInt64.1.cs
+++ b/tests/src/JIT/HardwareIntrinsics/General/Vector256_1/GetAndWithElement.UInt64.1.cs
@@ -74,10 +74,10 @@ public void RunBasicScenario(int imm = 1, bool expectedOutOfRangeException = fal
 
             if (!succeeded)
             {
-                Succeeded = false;
-
                 TestLibrary.TestFramework.LogInformation($"Vector256<UInt64.GetElement({imm}): {nameof(RunBasicScenario)} failed to throw ArgumentOutOfRangeException.");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
 
             succeeded = !expectedOutOfRangeException;
@@ -96,10 +96,10 @@ public void RunBasicScenario(int imm = 1, bool expectedOutOfRangeException = fal
 
             if (!succeeded)
             {
-                Succeeded = false;
-
                 TestLibrary.TestFramework.LogInformation($"Vector256<UInt64.WithElement({imm}): {nameof(RunBasicScenario)} failed to throw ArgumentOutOfRangeException.");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
 
@@ -133,10 +133,10 @@ public void RunReflectionScenario(int imm = 1, bool expectedOutOfRangeException
 
             if (!succeeded)
             {
-                Succeeded = false;
-
                 TestLibrary.TestFramework.LogInformation($"Vector256<UInt64.GetElement({imm}): {nameof(RunReflectionScenario)} failed to throw ArgumentOutOfRangeException.");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
 
             succeeded = !expectedOutOfRangeException;
@@ -158,10 +158,10 @@ public void RunReflectionScenario(int imm = 1, bool expectedOutOfRangeException
 
             if (!succeeded)
             {
-                Succeeded = false;
-
                 TestLibrary.TestFramework.LogInformation($"Vector256<UInt64.WithElement({imm}): {nameof(RunReflectionScenario)} failed to throw ArgumentOutOfRangeException.");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
 
@@ -196,27 +196,31 @@ private void ValidateWithResult(Vector256<UInt64> result, UInt64[] values, UInt6
 
         private void ValidateWithResult(UInt64[] result, UInt64[] values, UInt64 insertedValue, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             for (int i = 0; i < ElementCount; i++)
             {
                 if ((i != 1) && (result[i] != values[i]))
                 {
-                    Succeeded = false;
+                    succeeded = false;
                     break;
                 }
             }
 
             if (result[1] != insertedValue)
             {
-                Succeeded = false;
+                succeeded = false;
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"Vector256<UInt64.WithElement(1): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"   value: ({string.Join(", ", values)})");
                 TestLibrary.TestFramework.LogInformation($"  insert: insertedValue");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/General/Vector256_1/GetAndWithElement.UInt64.3.cs b/tests/src/JIT/HardwareIntrinsics/General/Vector256_1/GetAndWithElement.UInt64.3.cs
index 9c1eceecf325..0332859ffb58 100644
--- a/tests/src/JIT/HardwareIntrinsics/General/Vector256_1/GetAndWithElement.UInt64.3.cs
+++ b/tests/src/JIT/HardwareIntrinsics/General/Vector256_1/GetAndWithElement.UInt64.3.cs
@@ -74,10 +74,10 @@ public void RunBasicScenario(int imm = 3, bool expectedOutOfRangeException = fal
 
             if (!succeeded)
             {
-                Succeeded = false;
-
                 TestLibrary.TestFramework.LogInformation($"Vector256<UInt64.GetElement({imm}): {nameof(RunBasicScenario)} failed to throw ArgumentOutOfRangeException.");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
 
             succeeded = !expectedOutOfRangeException;
@@ -96,10 +96,10 @@ public void RunBasicScenario(int imm = 3, bool expectedOutOfRangeException = fal
 
             if (!succeeded)
             {
-                Succeeded = false;
-
                 TestLibrary.TestFramework.LogInformation($"Vector256<UInt64.WithElement({imm}): {nameof(RunBasicScenario)} failed to throw ArgumentOutOfRangeException.");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
 
@@ -133,10 +133,10 @@ public void RunReflectionScenario(int imm = 3, bool expectedOutOfRangeException
 
             if (!succeeded)
             {
-                Succeeded = false;
-
                 TestLibrary.TestFramework.LogInformation($"Vector256<UInt64.GetElement({imm}): {nameof(RunReflectionScenario)} failed to throw ArgumentOutOfRangeException.");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
 
             succeeded = !expectedOutOfRangeException;
@@ -158,10 +158,10 @@ public void RunReflectionScenario(int imm = 3, bool expectedOutOfRangeException
 
             if (!succeeded)
             {
-                Succeeded = false;
-
                 TestLibrary.TestFramework.LogInformation($"Vector256<UInt64.WithElement({imm}): {nameof(RunReflectionScenario)} failed to throw ArgumentOutOfRangeException.");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
 
@@ -196,27 +196,31 @@ private void ValidateWithResult(Vector256<UInt64> result, UInt64[] values, UInt6
 
         private void ValidateWithResult(UInt64[] result, UInt64[] values, UInt64 insertedValue, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             for (int i = 0; i < ElementCount; i++)
             {
                 if ((i != 3) && (result[i] != values[i]))
                 {
-                    Succeeded = false;
+                    succeeded = false;
                     break;
                 }
             }
 
             if (result[3] != insertedValue)
             {
-                Succeeded = false;
+                succeeded = false;
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"Vector256<UInt64.WithElement(3): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"   value: ({string.Join(", ", values)})");
                 TestLibrary.TestFramework.LogInformation($"  insert: insertedValue");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/General/Vector256_1/GetAndWithLowerAndUpper.Byte.cs b/tests/src/JIT/HardwareIntrinsics/General/Vector256_1/GetAndWithLowerAndUpper.Byte.cs
index 1d8afc7347e2..ca5a91e23e1e 100644
--- a/tests/src/JIT/HardwareIntrinsics/General/Vector256_1/GetAndWithLowerAndUpper.Byte.cs
+++ b/tests/src/JIT/HardwareIntrinsics/General/Vector256_1/GetAndWithLowerAndUpper.Byte.cs
@@ -108,38 +108,46 @@ private void ValidateGetResult(Vector128<Byte> lowerResult, Vector128<Byte> uppe
 
         private void ValidateGetResult(Byte[] lowerResult, Byte[] upperResult, Byte[] values, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             for (int i = 0; i < ElementCount / 2; i++)
             {
                 if (lowerResult[i] != values[i])
                 {
-                    Succeeded = false;
+                    succeeded = false;
                     break;
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"Vector256<Byte>.GetLower(): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"   value: ({string.Join(", ", values)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", lowerResult)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
 
+            succeeded = true;
+
             for (int i = ElementCount / 2; i < ElementCount; i++)
             {
                 if (upperResult[i - (ElementCount / 2)] != values[i])
                 {
-                    Succeeded = false;
+                    succeeded = false;
                     break;
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"Vector256<Byte>.GetUpper(): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"   value: ({string.Join(", ", values)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", upperResult)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
 
@@ -152,38 +160,46 @@ private void ValidateWithResult(Vector256<Byte> result, Byte[] values, [CallerMe
 
         private void ValidateWithResult(Byte[] result, Byte[] values, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             for (int i = 0; i < ElementCount / 2; i++)
             {
                 if (result[i] != values[i + (ElementCount / 2)])
                 {
-                    Succeeded = false;
+                    succeeded = false;
                     break;
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"Vector256<Byte.WithLower(): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"   value: ({string.Join(", ", values)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
 
+            succeeded = true;
+
             for (int i = ElementCount / 2; i < ElementCount; i++)
             {
                 if (result[i] != values[i - (ElementCount / 2)])
                 {
-                    Succeeded = false;
+                    succeeded = false;
                     break;
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"Vector256<Byte.WithUpper(): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"   value: ({string.Join(", ", values)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/General/Vector256_1/GetAndWithLowerAndUpper.Double.cs b/tests/src/JIT/HardwareIntrinsics/General/Vector256_1/GetAndWithLowerAndUpper.Double.cs
index 563975b8186b..35a3b5d393da 100644
--- a/tests/src/JIT/HardwareIntrinsics/General/Vector256_1/GetAndWithLowerAndUpper.Double.cs
+++ b/tests/src/JIT/HardwareIntrinsics/General/Vector256_1/GetAndWithLowerAndUpper.Double.cs
@@ -108,38 +108,46 @@ private void ValidateGetResult(Vector128<Double> lowerResult, Vector128<Double>
 
         private void ValidateGetResult(Double[] lowerResult, Double[] upperResult, Double[] values, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             for (int i = 0; i < ElementCount / 2; i++)
             {
                 if (lowerResult[i] != values[i])
                 {
-                    Succeeded = false;
+                    succeeded = false;
                     break;
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"Vector256<Double>.GetLower(): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"   value: ({string.Join(", ", values)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", lowerResult)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
 
+            succeeded = true;
+
             for (int i = ElementCount / 2; i < ElementCount; i++)
             {
                 if (upperResult[i - (ElementCount / 2)] != values[i])
                 {
-                    Succeeded = false;
+                    succeeded = false;
                     break;
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"Vector256<Double>.GetUpper(): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"   value: ({string.Join(", ", values)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", upperResult)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
 
@@ -152,38 +160,46 @@ private void ValidateWithResult(Vector256<Double> result, Double[] values, [Call
 
         private void ValidateWithResult(Double[] result, Double[] values, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             for (int i = 0; i < ElementCount / 2; i++)
             {
                 if (result[i] != values[i + (ElementCount / 2)])
                 {
-                    Succeeded = false;
+                    succeeded = false;
                     break;
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"Vector256<Double.WithLower(): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"   value: ({string.Join(", ", values)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
 
+            succeeded = true;
+
             for (int i = ElementCount / 2; i < ElementCount; i++)
             {
                 if (result[i] != values[i - (ElementCount / 2)])
                 {
-                    Succeeded = false;
+                    succeeded = false;
                     break;
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"Vector256<Double.WithUpper(): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"   value: ({string.Join(", ", values)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/General/Vector256_1/GetAndWithLowerAndUpper.Int16.cs b/tests/src/JIT/HardwareIntrinsics/General/Vector256_1/GetAndWithLowerAndUpper.Int16.cs
index 89b38e16a83a..56495b6e791d 100644
--- a/tests/src/JIT/HardwareIntrinsics/General/Vector256_1/GetAndWithLowerAndUpper.Int16.cs
+++ b/tests/src/JIT/HardwareIntrinsics/General/Vector256_1/GetAndWithLowerAndUpper.Int16.cs
@@ -108,38 +108,46 @@ private void ValidateGetResult(Vector128<Int16> lowerResult, Vector128<Int16> up
 
         private void ValidateGetResult(Int16[] lowerResult, Int16[] upperResult, Int16[] values, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             for (int i = 0; i < ElementCount / 2; i++)
             {
                 if (lowerResult[i] != values[i])
                 {
-                    Succeeded = false;
+                    succeeded = false;
                     break;
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"Vector256<Int16>.GetLower(): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"   value: ({string.Join(", ", values)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", lowerResult)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
 
+            succeeded = true;
+
             for (int i = ElementCount / 2; i < ElementCount; i++)
             {
                 if (upperResult[i - (ElementCount / 2)] != values[i])
                 {
-                    Succeeded = false;
+                    succeeded = false;
                     break;
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"Vector256<Int16>.GetUpper(): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"   value: ({string.Join(", ", values)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", upperResult)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
 
@@ -152,38 +160,46 @@ private void ValidateWithResult(Vector256<Int16> result, Int16[] values, [Caller
 
         private void ValidateWithResult(Int16[] result, Int16[] values, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             for (int i = 0; i < ElementCount / 2; i++)
             {
                 if (result[i] != values[i + (ElementCount / 2)])
                 {
-                    Succeeded = false;
+                    succeeded = false;
                     break;
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"Vector256<Int16.WithLower(): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"   value: ({string.Join(", ", values)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
 
+            succeeded = true;
+
             for (int i = ElementCount / 2; i < ElementCount; i++)
             {
                 if (result[i] != values[i - (ElementCount / 2)])
                 {
-                    Succeeded = false;
+                    succeeded = false;
                     break;
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"Vector256<Int16.WithUpper(): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"   value: ({string.Join(", ", values)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/General/Vector256_1/GetAndWithLowerAndUpper.Int32.cs b/tests/src/JIT/HardwareIntrinsics/General/Vector256_1/GetAndWithLowerAndUpper.Int32.cs
index 6ca4f1217046..ac6111da4c58 100644
--- a/tests/src/JIT/HardwareIntrinsics/General/Vector256_1/GetAndWithLowerAndUpper.Int32.cs
+++ b/tests/src/JIT/HardwareIntrinsics/General/Vector256_1/GetAndWithLowerAndUpper.Int32.cs
@@ -108,38 +108,46 @@ private void ValidateGetResult(Vector128<Int32> lowerResult, Vector128<Int32> up
 
         private void ValidateGetResult(Int32[] lowerResult, Int32[] upperResult, Int32[] values, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             for (int i = 0; i < ElementCount / 2; i++)
             {
                 if (lowerResult[i] != values[i])
                 {
-                    Succeeded = false;
+                    succeeded = false;
                     break;
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"Vector256<Int32>.GetLower(): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"   value: ({string.Join(", ", values)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", lowerResult)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
 
+            succeeded = true;
+
             for (int i = ElementCount / 2; i < ElementCount; i++)
             {
                 if (upperResult[i - (ElementCount / 2)] != values[i])
                 {
-                    Succeeded = false;
+                    succeeded = false;
                     break;
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"Vector256<Int32>.GetUpper(): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"   value: ({string.Join(", ", values)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", upperResult)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
 
@@ -152,38 +160,46 @@ private void ValidateWithResult(Vector256<Int32> result, Int32[] values, [Caller
 
         private void ValidateWithResult(Int32[] result, Int32[] values, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             for (int i = 0; i < ElementCount / 2; i++)
             {
                 if (result[i] != values[i + (ElementCount / 2)])
                 {
-                    Succeeded = false;
+                    succeeded = false;
                     break;
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"Vector256<Int32.WithLower(): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"   value: ({string.Join(", ", values)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
 
+            succeeded = true;
+
             for (int i = ElementCount / 2; i < ElementCount; i++)
             {
                 if (result[i] != values[i - (ElementCount / 2)])
                 {
-                    Succeeded = false;
+                    succeeded = false;
                     break;
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"Vector256<Int32.WithUpper(): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"   value: ({string.Join(", ", values)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/General/Vector256_1/GetAndWithLowerAndUpper.Int64.cs b/tests/src/JIT/HardwareIntrinsics/General/Vector256_1/GetAndWithLowerAndUpper.Int64.cs
index 9312d8f64827..013ffc96c044 100644
--- a/tests/src/JIT/HardwareIntrinsics/General/Vector256_1/GetAndWithLowerAndUpper.Int64.cs
+++ b/tests/src/JIT/HardwareIntrinsics/General/Vector256_1/GetAndWithLowerAndUpper.Int64.cs
@@ -108,38 +108,46 @@ private void ValidateGetResult(Vector128<Int64> lowerResult, Vector128<Int64> up
 
         private void ValidateGetResult(Int64[] lowerResult, Int64[] upperResult, Int64[] values, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             for (int i = 0; i < ElementCount / 2; i++)
             {
                 if (lowerResult[i] != values[i])
                 {
-                    Succeeded = false;
+                    succeeded = false;
                     break;
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"Vector256<Int64>.GetLower(): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"   value: ({string.Join(", ", values)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", lowerResult)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
 
+            succeeded = true;
+
             for (int i = ElementCount / 2; i < ElementCount; i++)
             {
                 if (upperResult[i - (ElementCount / 2)] != values[i])
                 {
-                    Succeeded = false;
+                    succeeded = false;
                     break;
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"Vector256<Int64>.GetUpper(): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"   value: ({string.Join(", ", values)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", upperResult)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
 
@@ -152,38 +160,46 @@ private void ValidateWithResult(Vector256<Int64> result, Int64[] values, [Caller
 
         private void ValidateWithResult(Int64[] result, Int64[] values, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             for (int i = 0; i < ElementCount / 2; i++)
             {
                 if (result[i] != values[i + (ElementCount / 2)])
                 {
-                    Succeeded = false;
+                    succeeded = false;
                     break;
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"Vector256<Int64.WithLower(): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"   value: ({string.Join(", ", values)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
 
+            succeeded = true;
+
             for (int i = ElementCount / 2; i < ElementCount; i++)
             {
                 if (result[i] != values[i - (ElementCount / 2)])
                 {
-                    Succeeded = false;
+                    succeeded = false;
                     break;
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"Vector256<Int64.WithUpper(): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"   value: ({string.Join(", ", values)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/General/Vector256_1/GetAndWithLowerAndUpper.SByte.cs b/tests/src/JIT/HardwareIntrinsics/General/Vector256_1/GetAndWithLowerAndUpper.SByte.cs
index 73a735749253..696a4f56c8ac 100644
--- a/tests/src/JIT/HardwareIntrinsics/General/Vector256_1/GetAndWithLowerAndUpper.SByte.cs
+++ b/tests/src/JIT/HardwareIntrinsics/General/Vector256_1/GetAndWithLowerAndUpper.SByte.cs
@@ -108,38 +108,46 @@ private void ValidateGetResult(Vector128<SByte> lowerResult, Vector128<SByte> up
 
         private void ValidateGetResult(SByte[] lowerResult, SByte[] upperResult, SByte[] values, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             for (int i = 0; i < ElementCount / 2; i++)
             {
                 if (lowerResult[i] != values[i])
                 {
-                    Succeeded = false;
+                    succeeded = false;
                     break;
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"Vector256<SByte>.GetLower(): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"   value: ({string.Join(", ", values)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", lowerResult)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
 
+            succeeded = true;
+
             for (int i = ElementCount / 2; i < ElementCount; i++)
             {
                 if (upperResult[i - (ElementCount / 2)] != values[i])
                 {
-                    Succeeded = false;
+                    succeeded = false;
                     break;
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"Vector256<SByte>.GetUpper(): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"   value: ({string.Join(", ", values)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", upperResult)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
 
@@ -152,38 +160,46 @@ private void ValidateWithResult(Vector256<SByte> result, SByte[] values, [Caller
 
         private void ValidateWithResult(SByte[] result, SByte[] values, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             for (int i = 0; i < ElementCount / 2; i++)
             {
                 if (result[i] != values[i + (ElementCount / 2)])
                 {
-                    Succeeded = false;
+                    succeeded = false;
                     break;
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"Vector256<SByte.WithLower(): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"   value: ({string.Join(", ", values)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
 
+            succeeded = true;
+
             for (int i = ElementCount / 2; i < ElementCount; i++)
             {
                 if (result[i] != values[i - (ElementCount / 2)])
                 {
-                    Succeeded = false;
+                    succeeded = false;
                     break;
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"Vector256<SByte.WithUpper(): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"   value: ({string.Join(", ", values)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/General/Vector256_1/GetAndWithLowerAndUpper.Single.cs b/tests/src/JIT/HardwareIntrinsics/General/Vector256_1/GetAndWithLowerAndUpper.Single.cs
index 6f9d1f7a392d..beb9d6069dbd 100644
--- a/tests/src/JIT/HardwareIntrinsics/General/Vector256_1/GetAndWithLowerAndUpper.Single.cs
+++ b/tests/src/JIT/HardwareIntrinsics/General/Vector256_1/GetAndWithLowerAndUpper.Single.cs
@@ -108,38 +108,46 @@ private void ValidateGetResult(Vector128<Single> lowerResult, Vector128<Single>
 
         private void ValidateGetResult(Single[] lowerResult, Single[] upperResult, Single[] values, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             for (int i = 0; i < ElementCount / 2; i++)
             {
                 if (lowerResult[i] != values[i])
                 {
-                    Succeeded = false;
+                    succeeded = false;
                     break;
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"Vector256<Single>.GetLower(): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"   value: ({string.Join(", ", values)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", lowerResult)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
 
+            succeeded = true;
+
             for (int i = ElementCount / 2; i < ElementCount; i++)
             {
                 if (upperResult[i - (ElementCount / 2)] != values[i])
                 {
-                    Succeeded = false;
+                    succeeded = false;
                     break;
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"Vector256<Single>.GetUpper(): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"   value: ({string.Join(", ", values)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", upperResult)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
 
@@ -152,38 +160,46 @@ private void ValidateWithResult(Vector256<Single> result, Single[] values, [Call
 
         private void ValidateWithResult(Single[] result, Single[] values, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             for (int i = 0; i < ElementCount / 2; i++)
             {
                 if (result[i] != values[i + (ElementCount / 2)])
                 {
-                    Succeeded = false;
+                    succeeded = false;
                     break;
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"Vector256<Single.WithLower(): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"   value: ({string.Join(", ", values)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
 
+            succeeded = true;
+
             for (int i = ElementCount / 2; i < ElementCount; i++)
             {
                 if (result[i] != values[i - (ElementCount / 2)])
                 {
-                    Succeeded = false;
+                    succeeded = false;
                     break;
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"Vector256<Single.WithUpper(): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"   value: ({string.Join(", ", values)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/General/Vector256_1/GetAndWithLowerAndUpper.UInt16.cs b/tests/src/JIT/HardwareIntrinsics/General/Vector256_1/GetAndWithLowerAndUpper.UInt16.cs
index 75a5c7362387..d0948989eaed 100644
--- a/tests/src/JIT/HardwareIntrinsics/General/Vector256_1/GetAndWithLowerAndUpper.UInt16.cs
+++ b/tests/src/JIT/HardwareIntrinsics/General/Vector256_1/GetAndWithLowerAndUpper.UInt16.cs
@@ -108,38 +108,46 @@ private void ValidateGetResult(Vector128<UInt16> lowerResult, Vector128<UInt16>
 
         private void ValidateGetResult(UInt16[] lowerResult, UInt16[] upperResult, UInt16[] values, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             for (int i = 0; i < ElementCount / 2; i++)
             {
                 if (lowerResult[i] != values[i])
                 {
-                    Succeeded = false;
+                    succeeded = false;
                     break;
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"Vector256<UInt16>.GetLower(): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"   value: ({string.Join(", ", values)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", lowerResult)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
 
+            succeeded = true;
+
             for (int i = ElementCount / 2; i < ElementCount; i++)
             {
                 if (upperResult[i - (ElementCount / 2)] != values[i])
                 {
-                    Succeeded = false;
+                    succeeded = false;
                     break;
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"Vector256<UInt16>.GetUpper(): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"   value: ({string.Join(", ", values)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", upperResult)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
 
@@ -152,38 +160,46 @@ private void ValidateWithResult(Vector256<UInt16> result, UInt16[] values, [Call
 
         private void ValidateWithResult(UInt16[] result, UInt16[] values, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             for (int i = 0; i < ElementCount / 2; i++)
             {
                 if (result[i] != values[i + (ElementCount / 2)])
                 {
-                    Succeeded = false;
+                    succeeded = false;
                     break;
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"Vector256<UInt16.WithLower(): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"   value: ({string.Join(", ", values)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
 
+            succeeded = true;
+
             for (int i = ElementCount / 2; i < ElementCount; i++)
             {
                 if (result[i] != values[i - (ElementCount / 2)])
                 {
-                    Succeeded = false;
+                    succeeded = false;
                     break;
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"Vector256<UInt16.WithUpper(): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"   value: ({string.Join(", ", values)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/General/Vector256_1/GetAndWithLowerAndUpper.UInt32.cs b/tests/src/JIT/HardwareIntrinsics/General/Vector256_1/GetAndWithLowerAndUpper.UInt32.cs
index 4f07a8c8ba4c..25264bd9684b 100644
--- a/tests/src/JIT/HardwareIntrinsics/General/Vector256_1/GetAndWithLowerAndUpper.UInt32.cs
+++ b/tests/src/JIT/HardwareIntrinsics/General/Vector256_1/GetAndWithLowerAndUpper.UInt32.cs
@@ -108,38 +108,46 @@ private void ValidateGetResult(Vector128<UInt32> lowerResult, Vector128<UInt32>
 
         private void ValidateGetResult(UInt32[] lowerResult, UInt32[] upperResult, UInt32[] values, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             for (int i = 0; i < ElementCount / 2; i++)
             {
                 if (lowerResult[i] != values[i])
                 {
-                    Succeeded = false;
+                    succeeded = false;
                     break;
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"Vector256<UInt32>.GetLower(): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"   value: ({string.Join(", ", values)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", lowerResult)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
 
+            succeeded = true;
+
             for (int i = ElementCount / 2; i < ElementCount; i++)
             {
                 if (upperResult[i - (ElementCount / 2)] != values[i])
                 {
-                    Succeeded = false;
+                    succeeded = false;
                     break;
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"Vector256<UInt32>.GetUpper(): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"   value: ({string.Join(", ", values)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", upperResult)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
 
@@ -152,38 +160,46 @@ private void ValidateWithResult(Vector256<UInt32> result, UInt32[] values, [Call
 
         private void ValidateWithResult(UInt32[] result, UInt32[] values, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             for (int i = 0; i < ElementCount / 2; i++)
             {
                 if (result[i] != values[i + (ElementCount / 2)])
                 {
-                    Succeeded = false;
+                    succeeded = false;
                     break;
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"Vector256<UInt32.WithLower(): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"   value: ({string.Join(", ", values)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
 
+            succeeded = true;
+
             for (int i = ElementCount / 2; i < ElementCount; i++)
             {
                 if (result[i] != values[i - (ElementCount / 2)])
                 {
-                    Succeeded = false;
+                    succeeded = false;
                     break;
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"Vector256<UInt32.WithUpper(): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"   value: ({string.Join(", ", values)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/General/Vector256_1/GetAndWithLowerAndUpper.UInt64.cs b/tests/src/JIT/HardwareIntrinsics/General/Vector256_1/GetAndWithLowerAndUpper.UInt64.cs
index d8e0cf99bb15..8f100d726f5f 100644
--- a/tests/src/JIT/HardwareIntrinsics/General/Vector256_1/GetAndWithLowerAndUpper.UInt64.cs
+++ b/tests/src/JIT/HardwareIntrinsics/General/Vector256_1/GetAndWithLowerAndUpper.UInt64.cs
@@ -108,38 +108,46 @@ private void ValidateGetResult(Vector128<UInt64> lowerResult, Vector128<UInt64>
 
         private void ValidateGetResult(UInt64[] lowerResult, UInt64[] upperResult, UInt64[] values, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             for (int i = 0; i < ElementCount / 2; i++)
             {
                 if (lowerResult[i] != values[i])
                 {
-                    Succeeded = false;
+                    succeeded = false;
                     break;
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"Vector256<UInt64>.GetLower(): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"   value: ({string.Join(", ", values)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", lowerResult)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
 
+            succeeded = true;
+
             for (int i = ElementCount / 2; i < ElementCount; i++)
             {
                 if (upperResult[i - (ElementCount / 2)] != values[i])
                 {
-                    Succeeded = false;
+                    succeeded = false;
                     break;
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"Vector256<UInt64>.GetUpper(): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"   value: ({string.Join(", ", values)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", upperResult)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
 
@@ -152,38 +160,46 @@ private void ValidateWithResult(Vector256<UInt64> result, UInt64[] values, [Call
 
         private void ValidateWithResult(UInt64[] result, UInt64[] values, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             for (int i = 0; i < ElementCount / 2; i++)
             {
                 if (result[i] != values[i + (ElementCount / 2)])
                 {
-                    Succeeded = false;
+                    succeeded = false;
                     break;
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"Vector256<UInt64.WithLower(): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"   value: ({string.Join(", ", values)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
 
+            succeeded = true;
+
             for (int i = ElementCount / 2; i < ElementCount; i++)
             {
                 if (result[i] != values[i - (ElementCount / 2)])
                 {
-                    Succeeded = false;
+                    succeeded = false;
                     break;
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"Vector256<UInt64.WithUpper(): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"   value: ({string.Join(", ", values)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/General/Vector256_1/ToScalar.Byte.cs b/tests/src/JIT/HardwareIntrinsics/General/Vector256_1/ToScalar.Byte.cs
index 65ec28e972d5..4379629ad3c4 100644
--- a/tests/src/JIT/HardwareIntrinsics/General/Vector256_1/ToScalar.Byte.cs
+++ b/tests/src/JIT/HardwareIntrinsics/General/Vector256_1/ToScalar.Byte.cs
@@ -84,12 +84,12 @@ private void ValidateResult(Byte result, Byte[] values, [CallerMemberName] strin
         {
             if (result != values[0])
             {
-                Succeeded = false;
-
                 TestLibrary.TestFramework.LogInformation($"Vector256<Byte>.ToScalar(): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"  values: ({string.Join(", ", values)})");
                 TestLibrary.TestFramework.LogInformation($"  result: {result}");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/General/Vector256_1/ToScalar.Double.cs b/tests/src/JIT/HardwareIntrinsics/General/Vector256_1/ToScalar.Double.cs
index 797df28187b2..458339034409 100644
--- a/tests/src/JIT/HardwareIntrinsics/General/Vector256_1/ToScalar.Double.cs
+++ b/tests/src/JIT/HardwareIntrinsics/General/Vector256_1/ToScalar.Double.cs
@@ -84,12 +84,12 @@ private void ValidateResult(Double result, Double[] values, [CallerMemberName] s
         {
             if (result != values[0])
             {
-                Succeeded = false;
-
                 TestLibrary.TestFramework.LogInformation($"Vector256<Double>.ToScalar(): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"  values: ({string.Join(", ", values)})");
                 TestLibrary.TestFramework.LogInformation($"  result: {result}");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/General/Vector256_1/ToScalar.Int16.cs b/tests/src/JIT/HardwareIntrinsics/General/Vector256_1/ToScalar.Int16.cs
index 54d4ae9e7151..b1365b31dea2 100644
--- a/tests/src/JIT/HardwareIntrinsics/General/Vector256_1/ToScalar.Int16.cs
+++ b/tests/src/JIT/HardwareIntrinsics/General/Vector256_1/ToScalar.Int16.cs
@@ -84,12 +84,12 @@ private void ValidateResult(Int16 result, Int16[] values, [CallerMemberName] str
         {
             if (result != values[0])
             {
-                Succeeded = false;
-
                 TestLibrary.TestFramework.LogInformation($"Vector256<Int16>.ToScalar(): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"  values: ({string.Join(", ", values)})");
                 TestLibrary.TestFramework.LogInformation($"  result: {result}");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/General/Vector256_1/ToScalar.Int32.cs b/tests/src/JIT/HardwareIntrinsics/General/Vector256_1/ToScalar.Int32.cs
index 4b1653c22ab5..0728b813ab1b 100644
--- a/tests/src/JIT/HardwareIntrinsics/General/Vector256_1/ToScalar.Int32.cs
+++ b/tests/src/JIT/HardwareIntrinsics/General/Vector256_1/ToScalar.Int32.cs
@@ -84,12 +84,12 @@ private void ValidateResult(Int32 result, Int32[] values, [CallerMemberName] str
         {
             if (result != values[0])
             {
-                Succeeded = false;
-
                 TestLibrary.TestFramework.LogInformation($"Vector256<Int32>.ToScalar(): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"  values: ({string.Join(", ", values)})");
                 TestLibrary.TestFramework.LogInformation($"  result: {result}");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/General/Vector256_1/ToScalar.Int64.cs b/tests/src/JIT/HardwareIntrinsics/General/Vector256_1/ToScalar.Int64.cs
index cd2c54b409d3..50befc66c3cb 100644
--- a/tests/src/JIT/HardwareIntrinsics/General/Vector256_1/ToScalar.Int64.cs
+++ b/tests/src/JIT/HardwareIntrinsics/General/Vector256_1/ToScalar.Int64.cs
@@ -84,12 +84,12 @@ private void ValidateResult(Int64 result, Int64[] values, [CallerMemberName] str
         {
             if (result != values[0])
             {
-                Succeeded = false;
-
                 TestLibrary.TestFramework.LogInformation($"Vector256<Int64>.ToScalar(): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"  values: ({string.Join(", ", values)})");
                 TestLibrary.TestFramework.LogInformation($"  result: {result}");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/General/Vector256_1/ToScalar.SByte.cs b/tests/src/JIT/HardwareIntrinsics/General/Vector256_1/ToScalar.SByte.cs
index 729494e3f18b..e41e5e4f2246 100644
--- a/tests/src/JIT/HardwareIntrinsics/General/Vector256_1/ToScalar.SByte.cs
+++ b/tests/src/JIT/HardwareIntrinsics/General/Vector256_1/ToScalar.SByte.cs
@@ -84,12 +84,12 @@ private void ValidateResult(SByte result, SByte[] values, [CallerMemberName] str
         {
             if (result != values[0])
             {
-                Succeeded = false;
-
                 TestLibrary.TestFramework.LogInformation($"Vector256<SByte>.ToScalar(): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"  values: ({string.Join(", ", values)})");
                 TestLibrary.TestFramework.LogInformation($"  result: {result}");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/General/Vector256_1/ToScalar.Single.cs b/tests/src/JIT/HardwareIntrinsics/General/Vector256_1/ToScalar.Single.cs
index c3409c046e31..1cacfe35e3f8 100644
--- a/tests/src/JIT/HardwareIntrinsics/General/Vector256_1/ToScalar.Single.cs
+++ b/tests/src/JIT/HardwareIntrinsics/General/Vector256_1/ToScalar.Single.cs
@@ -84,12 +84,12 @@ private void ValidateResult(Single result, Single[] values, [CallerMemberName] s
         {
             if (result != values[0])
             {
-                Succeeded = false;
-
                 TestLibrary.TestFramework.LogInformation($"Vector256<Single>.ToScalar(): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"  values: ({string.Join(", ", values)})");
                 TestLibrary.TestFramework.LogInformation($"  result: {result}");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/General/Vector256_1/ToScalar.UInt16.cs b/tests/src/JIT/HardwareIntrinsics/General/Vector256_1/ToScalar.UInt16.cs
index 9be837d1a552..135a2c47c8d5 100644
--- a/tests/src/JIT/HardwareIntrinsics/General/Vector256_1/ToScalar.UInt16.cs
+++ b/tests/src/JIT/HardwareIntrinsics/General/Vector256_1/ToScalar.UInt16.cs
@@ -84,12 +84,12 @@ private void ValidateResult(UInt16 result, UInt16[] values, [CallerMemberName] s
         {
             if (result != values[0])
             {
-                Succeeded = false;
-
                 TestLibrary.TestFramework.LogInformation($"Vector256<UInt16>.ToScalar(): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"  values: ({string.Join(", ", values)})");
                 TestLibrary.TestFramework.LogInformation($"  result: {result}");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/General/Vector256_1/ToScalar.UInt32.cs b/tests/src/JIT/HardwareIntrinsics/General/Vector256_1/ToScalar.UInt32.cs
index c8d752c83760..4c1f27cf3b71 100644
--- a/tests/src/JIT/HardwareIntrinsics/General/Vector256_1/ToScalar.UInt32.cs
+++ b/tests/src/JIT/HardwareIntrinsics/General/Vector256_1/ToScalar.UInt32.cs
@@ -84,12 +84,12 @@ private void ValidateResult(UInt32 result, UInt32[] values, [CallerMemberName] s
         {
             if (result != values[0])
             {
-                Succeeded = false;
-
                 TestLibrary.TestFramework.LogInformation($"Vector256<UInt32>.ToScalar(): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"  values: ({string.Join(", ", values)})");
                 TestLibrary.TestFramework.LogInformation($"  result: {result}");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/General/Vector256_1/ToScalar.UInt64.cs b/tests/src/JIT/HardwareIntrinsics/General/Vector256_1/ToScalar.UInt64.cs
index 381ee117b644..29f9a4d9b5cc 100644
--- a/tests/src/JIT/HardwareIntrinsics/General/Vector256_1/ToScalar.UInt64.cs
+++ b/tests/src/JIT/HardwareIntrinsics/General/Vector256_1/ToScalar.UInt64.cs
@@ -84,12 +84,12 @@ private void ValidateResult(UInt64 result, UInt64[] values, [CallerMemberName] s
         {
             if (result != values[0])
             {
-                Succeeded = false;
-
                 TestLibrary.TestFramework.LogInformation($"Vector256<UInt64>.ToScalar(): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"  values: ({string.Join(", ", values)})");
                 TestLibrary.TestFramework.LogInformation($"  result: {result}");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/General/Vector256_1/Zero.Byte.cs b/tests/src/JIT/HardwareIntrinsics/General/Vector256_1/Zero.Byte.cs
index b0edbfcdbfca..c7e6eb396f60 100644
--- a/tests/src/JIT/HardwareIntrinsics/General/Vector256_1/Zero.Byte.cs
+++ b/tests/src/JIT/HardwareIntrinsics/General/Vector256_1/Zero.Byte.cs
@@ -73,20 +73,24 @@ private void ValidateResult(Vector256<Byte> result, [CallerMemberName] string me
 
         private void ValidateResult(Byte[] resultElements, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+        
             for (var i = 0; i < ElementCount; i++)
             {
                 if (resultElements[i] != 0)
                 {
-                    Succeeded = false;
+                    succeeded = false;
                     break;
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"Vector256.Zero(Byte): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", resultElements)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/General/Vector256_1/Zero.Double.cs b/tests/src/JIT/HardwareIntrinsics/General/Vector256_1/Zero.Double.cs
index 49aec833208e..b72c208813ff 100644
--- a/tests/src/JIT/HardwareIntrinsics/General/Vector256_1/Zero.Double.cs
+++ b/tests/src/JIT/HardwareIntrinsics/General/Vector256_1/Zero.Double.cs
@@ -73,20 +73,24 @@ private void ValidateResult(Vector256<Double> result, [CallerMemberName] string
 
         private void ValidateResult(Double[] resultElements, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+        
             for (var i = 0; i < ElementCount; i++)
             {
                 if (resultElements[i] != 0)
                 {
-                    Succeeded = false;
+                    succeeded = false;
                     break;
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"Vector256.Zero(Double): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", resultElements)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/General/Vector256_1/Zero.Int16.cs b/tests/src/JIT/HardwareIntrinsics/General/Vector256_1/Zero.Int16.cs
index 18a7ce3ee4e1..02ed3b3497b5 100644
--- a/tests/src/JIT/HardwareIntrinsics/General/Vector256_1/Zero.Int16.cs
+++ b/tests/src/JIT/HardwareIntrinsics/General/Vector256_1/Zero.Int16.cs
@@ -73,20 +73,24 @@ private void ValidateResult(Vector256<Int16> result, [CallerMemberName] string m
 
         private void ValidateResult(Int16[] resultElements, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+        
             for (var i = 0; i < ElementCount; i++)
             {
                 if (resultElements[i] != 0)
                 {
-                    Succeeded = false;
+                    succeeded = false;
                     break;
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"Vector256.Zero(Int16): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", resultElements)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/General/Vector256_1/Zero.Int32.cs b/tests/src/JIT/HardwareIntrinsics/General/Vector256_1/Zero.Int32.cs
index d08c9f15a94b..9a90c7bc2ca7 100644
--- a/tests/src/JIT/HardwareIntrinsics/General/Vector256_1/Zero.Int32.cs
+++ b/tests/src/JIT/HardwareIntrinsics/General/Vector256_1/Zero.Int32.cs
@@ -73,20 +73,24 @@ private void ValidateResult(Vector256<Int32> result, [CallerMemberName] string m
 
         private void ValidateResult(Int32[] resultElements, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+        
             for (var i = 0; i < ElementCount; i++)
             {
                 if (resultElements[i] != 0)
                 {
-                    Succeeded = false;
+                    succeeded = false;
                     break;
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"Vector256.Zero(Int32): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", resultElements)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/General/Vector256_1/Zero.Int64.cs b/tests/src/JIT/HardwareIntrinsics/General/Vector256_1/Zero.Int64.cs
index 9545a41de18f..17766dbf0b5f 100644
--- a/tests/src/JIT/HardwareIntrinsics/General/Vector256_1/Zero.Int64.cs
+++ b/tests/src/JIT/HardwareIntrinsics/General/Vector256_1/Zero.Int64.cs
@@ -73,20 +73,24 @@ private void ValidateResult(Vector256<Int64> result, [CallerMemberName] string m
 
         private void ValidateResult(Int64[] resultElements, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+        
             for (var i = 0; i < ElementCount; i++)
             {
                 if (resultElements[i] != 0)
                 {
-                    Succeeded = false;
+                    succeeded = false;
                     break;
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"Vector256.Zero(Int64): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", resultElements)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/General/Vector256_1/Zero.SByte.cs b/tests/src/JIT/HardwareIntrinsics/General/Vector256_1/Zero.SByte.cs
index e8f0901cdc34..0d4d385e7ba1 100644
--- a/tests/src/JIT/HardwareIntrinsics/General/Vector256_1/Zero.SByte.cs
+++ b/tests/src/JIT/HardwareIntrinsics/General/Vector256_1/Zero.SByte.cs
@@ -73,20 +73,24 @@ private void ValidateResult(Vector256<SByte> result, [CallerMemberName] string m
 
         private void ValidateResult(SByte[] resultElements, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+        
             for (var i = 0; i < ElementCount; i++)
             {
                 if (resultElements[i] != 0)
                 {
-                    Succeeded = false;
+                    succeeded = false;
                     break;
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"Vector256.Zero(SByte): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", resultElements)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/General/Vector256_1/Zero.Single.cs b/tests/src/JIT/HardwareIntrinsics/General/Vector256_1/Zero.Single.cs
index 6a84d791856d..8a0f9877a890 100644
--- a/tests/src/JIT/HardwareIntrinsics/General/Vector256_1/Zero.Single.cs
+++ b/tests/src/JIT/HardwareIntrinsics/General/Vector256_1/Zero.Single.cs
@@ -73,20 +73,24 @@ private void ValidateResult(Vector256<Single> result, [CallerMemberName] string
 
         private void ValidateResult(Single[] resultElements, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+        
             for (var i = 0; i < ElementCount; i++)
             {
                 if (resultElements[i] != 0)
                 {
-                    Succeeded = false;
+                    succeeded = false;
                     break;
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"Vector256.Zero(Single): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", resultElements)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/General/Vector256_1/Zero.UInt16.cs b/tests/src/JIT/HardwareIntrinsics/General/Vector256_1/Zero.UInt16.cs
index d55888c08990..db2d0b2280d8 100644
--- a/tests/src/JIT/HardwareIntrinsics/General/Vector256_1/Zero.UInt16.cs
+++ b/tests/src/JIT/HardwareIntrinsics/General/Vector256_1/Zero.UInt16.cs
@@ -73,20 +73,24 @@ private void ValidateResult(Vector256<UInt16> result, [CallerMemberName] string
 
         private void ValidateResult(UInt16[] resultElements, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+        
             for (var i = 0; i < ElementCount; i++)
             {
                 if (resultElements[i] != 0)
                 {
-                    Succeeded = false;
+                    succeeded = false;
                     break;
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"Vector256.Zero(UInt16): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", resultElements)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/General/Vector256_1/Zero.UInt32.cs b/tests/src/JIT/HardwareIntrinsics/General/Vector256_1/Zero.UInt32.cs
index 25679e6af374..a00041ac1b65 100644
--- a/tests/src/JIT/HardwareIntrinsics/General/Vector256_1/Zero.UInt32.cs
+++ b/tests/src/JIT/HardwareIntrinsics/General/Vector256_1/Zero.UInt32.cs
@@ -73,20 +73,24 @@ private void ValidateResult(Vector256<UInt32> result, [CallerMemberName] string
 
         private void ValidateResult(UInt32[] resultElements, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+        
             for (var i = 0; i < ElementCount; i++)
             {
                 if (resultElements[i] != 0)
                 {
-                    Succeeded = false;
+                    succeeded = false;
                     break;
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"Vector256.Zero(UInt32): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", resultElements)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/General/Vector256_1/Zero.UInt64.cs b/tests/src/JIT/HardwareIntrinsics/General/Vector256_1/Zero.UInt64.cs
index 867a4848b01b..2b4c8f99e45f 100644
--- a/tests/src/JIT/HardwareIntrinsics/General/Vector256_1/Zero.UInt64.cs
+++ b/tests/src/JIT/HardwareIntrinsics/General/Vector256_1/Zero.UInt64.cs
@@ -73,20 +73,24 @@ private void ValidateResult(Vector256<UInt64> result, [CallerMemberName] string
 
         private void ValidateResult(UInt64[] resultElements, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+        
             for (var i = 0; i < ElementCount; i++)
             {
                 if (resultElements[i] != 0)
                 {
-                    Succeeded = false;
+                    succeeded = false;
                     break;
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"Vector256.Zero(UInt64): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", resultElements)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/General/Vector64/Create.Byte.cs b/tests/src/JIT/HardwareIntrinsics/General/Vector64/Create.Byte.cs
index 3d94caa1809f..4d3c7298cf73 100644
--- a/tests/src/JIT/HardwareIntrinsics/General/Vector64/Create.Byte.cs
+++ b/tests/src/JIT/HardwareIntrinsics/General/Vector64/Create.Byte.cs
@@ -74,9 +74,11 @@ private void ValidateResult(Vector64<Byte> result, Byte expectedValue, [CallerMe
 
         private void ValidateResult(Byte[] resultElements, Byte expectedValue, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (resultElements[0] != expectedValue)
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -84,18 +86,20 @@ private void ValidateResult(Byte[] resultElements, Byte expectedValue, [CallerMe
                 {
                     if (resultElements[i] != expectedValue)
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"Vector64.Create(Byte): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"   value: {expectedValue}");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", resultElements)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/General/Vector64/Create.Double.cs b/tests/src/JIT/HardwareIntrinsics/General/Vector64/Create.Double.cs
index 519c1db29054..ff17af824ac7 100644
--- a/tests/src/JIT/HardwareIntrinsics/General/Vector64/Create.Double.cs
+++ b/tests/src/JIT/HardwareIntrinsics/General/Vector64/Create.Double.cs
@@ -74,9 +74,11 @@ private void ValidateResult(Vector64<Double> result, Double expectedValue, [Call
 
         private void ValidateResult(Double[] resultElements, Double expectedValue, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (resultElements[0] != expectedValue)
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -84,18 +86,20 @@ private void ValidateResult(Double[] resultElements, Double expectedValue, [Call
                 {
                     if (resultElements[i] != expectedValue)
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"Vector64.Create(Double): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"   value: {expectedValue}");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", resultElements)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/General/Vector64/Create.Int16.cs b/tests/src/JIT/HardwareIntrinsics/General/Vector64/Create.Int16.cs
index 0f825a991b65..15a9a860748f 100644
--- a/tests/src/JIT/HardwareIntrinsics/General/Vector64/Create.Int16.cs
+++ b/tests/src/JIT/HardwareIntrinsics/General/Vector64/Create.Int16.cs
@@ -74,9 +74,11 @@ private void ValidateResult(Vector64<Int16> result, Int16 expectedValue, [Caller
 
         private void ValidateResult(Int16[] resultElements, Int16 expectedValue, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (resultElements[0] != expectedValue)
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -84,18 +86,20 @@ private void ValidateResult(Int16[] resultElements, Int16 expectedValue, [Caller
                 {
                     if (resultElements[i] != expectedValue)
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"Vector64.Create(Int16): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"   value: {expectedValue}");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", resultElements)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/General/Vector64/Create.Int32.cs b/tests/src/JIT/HardwareIntrinsics/General/Vector64/Create.Int32.cs
index 7d4feffbd1b0..fb210851b62d 100644
--- a/tests/src/JIT/HardwareIntrinsics/General/Vector64/Create.Int32.cs
+++ b/tests/src/JIT/HardwareIntrinsics/General/Vector64/Create.Int32.cs
@@ -74,9 +74,11 @@ private void ValidateResult(Vector64<Int32> result, Int32 expectedValue, [Caller
 
         private void ValidateResult(Int32[] resultElements, Int32 expectedValue, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (resultElements[0] != expectedValue)
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -84,18 +86,20 @@ private void ValidateResult(Int32[] resultElements, Int32 expectedValue, [Caller
                 {
                     if (resultElements[i] != expectedValue)
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"Vector64.Create(Int32): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"   value: {expectedValue}");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", resultElements)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/General/Vector64/Create.Int64.cs b/tests/src/JIT/HardwareIntrinsics/General/Vector64/Create.Int64.cs
index 734cde87f02e..31a677c915ef 100644
--- a/tests/src/JIT/HardwareIntrinsics/General/Vector64/Create.Int64.cs
+++ b/tests/src/JIT/HardwareIntrinsics/General/Vector64/Create.Int64.cs
@@ -74,9 +74,11 @@ private void ValidateResult(Vector64<Int64> result, Int64 expectedValue, [Caller
 
         private void ValidateResult(Int64[] resultElements, Int64 expectedValue, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (resultElements[0] != expectedValue)
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -84,18 +86,20 @@ private void ValidateResult(Int64[] resultElements, Int64 expectedValue, [Caller
                 {
                     if (resultElements[i] != expectedValue)
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"Vector64.Create(Int64): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"   value: {expectedValue}");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", resultElements)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/General/Vector64/Create.SByte.cs b/tests/src/JIT/HardwareIntrinsics/General/Vector64/Create.SByte.cs
index b437df7226c7..32c28f58f436 100644
--- a/tests/src/JIT/HardwareIntrinsics/General/Vector64/Create.SByte.cs
+++ b/tests/src/JIT/HardwareIntrinsics/General/Vector64/Create.SByte.cs
@@ -74,9 +74,11 @@ private void ValidateResult(Vector64<SByte> result, SByte expectedValue, [Caller
 
         private void ValidateResult(SByte[] resultElements, SByte expectedValue, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (resultElements[0] != expectedValue)
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -84,18 +86,20 @@ private void ValidateResult(SByte[] resultElements, SByte expectedValue, [Caller
                 {
                     if (resultElements[i] != expectedValue)
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"Vector64.Create(SByte): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"   value: {expectedValue}");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", resultElements)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/General/Vector64/Create.Single.cs b/tests/src/JIT/HardwareIntrinsics/General/Vector64/Create.Single.cs
index b8177753cdc1..66d6730eabc7 100644
--- a/tests/src/JIT/HardwareIntrinsics/General/Vector64/Create.Single.cs
+++ b/tests/src/JIT/HardwareIntrinsics/General/Vector64/Create.Single.cs
@@ -74,9 +74,11 @@ private void ValidateResult(Vector64<Single> result, Single expectedValue, [Call
 
         private void ValidateResult(Single[] resultElements, Single expectedValue, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (resultElements[0] != expectedValue)
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -84,18 +86,20 @@ private void ValidateResult(Single[] resultElements, Single expectedValue, [Call
                 {
                     if (resultElements[i] != expectedValue)
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"Vector64.Create(Single): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"   value: {expectedValue}");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", resultElements)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/General/Vector64/Create.UInt16.cs b/tests/src/JIT/HardwareIntrinsics/General/Vector64/Create.UInt16.cs
index fe64a1c03a96..5cb70e967f13 100644
--- a/tests/src/JIT/HardwareIntrinsics/General/Vector64/Create.UInt16.cs
+++ b/tests/src/JIT/HardwareIntrinsics/General/Vector64/Create.UInt16.cs
@@ -74,9 +74,11 @@ private void ValidateResult(Vector64<UInt16> result, UInt16 expectedValue, [Call
 
         private void ValidateResult(UInt16[] resultElements, UInt16 expectedValue, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (resultElements[0] != expectedValue)
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -84,18 +86,20 @@ private void ValidateResult(UInt16[] resultElements, UInt16 expectedValue, [Call
                 {
                     if (resultElements[i] != expectedValue)
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"Vector64.Create(UInt16): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"   value: {expectedValue}");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", resultElements)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/General/Vector64/Create.UInt32.cs b/tests/src/JIT/HardwareIntrinsics/General/Vector64/Create.UInt32.cs
index e6876bac0033..bd3b584da3e5 100644
--- a/tests/src/JIT/HardwareIntrinsics/General/Vector64/Create.UInt32.cs
+++ b/tests/src/JIT/HardwareIntrinsics/General/Vector64/Create.UInt32.cs
@@ -74,9 +74,11 @@ private void ValidateResult(Vector64<UInt32> result, UInt32 expectedValue, [Call
 
         private void ValidateResult(UInt32[] resultElements, UInt32 expectedValue, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (resultElements[0] != expectedValue)
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -84,18 +86,20 @@ private void ValidateResult(UInt32[] resultElements, UInt32 expectedValue, [Call
                 {
                     if (resultElements[i] != expectedValue)
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"Vector64.Create(UInt32): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"   value: {expectedValue}");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", resultElements)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/General/Vector64/Create.UInt64.cs b/tests/src/JIT/HardwareIntrinsics/General/Vector64/Create.UInt64.cs
index 936eb3df1376..ea2a12d37fe2 100644
--- a/tests/src/JIT/HardwareIntrinsics/General/Vector64/Create.UInt64.cs
+++ b/tests/src/JIT/HardwareIntrinsics/General/Vector64/Create.UInt64.cs
@@ -74,9 +74,11 @@ private void ValidateResult(Vector64<UInt64> result, UInt64 expectedValue, [Call
 
         private void ValidateResult(UInt64[] resultElements, UInt64 expectedValue, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (resultElements[0] != expectedValue)
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -84,18 +86,20 @@ private void ValidateResult(UInt64[] resultElements, UInt64 expectedValue, [Call
                 {
                     if (resultElements[i] != expectedValue)
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"Vector64.Create(UInt64): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"   value: {expectedValue}");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", resultElements)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/General/Vector64/CreateElement.Byte.cs b/tests/src/JIT/HardwareIntrinsics/General/Vector64/CreateElement.Byte.cs
index 79be2dfc9025..4d8ae817139e 100644
--- a/tests/src/JIT/HardwareIntrinsics/General/Vector64/CreateElement.Byte.cs
+++ b/tests/src/JIT/HardwareIntrinsics/General/Vector64/CreateElement.Byte.cs
@@ -88,21 +88,25 @@ private void ValidateResult(Vector64<Byte> result, Byte[] expectedValues, [Calle
 
         private void ValidateResult(Byte[] resultElements, Byte[] expectedValues, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             for (var i = 0; i < ElementCount; i++)
             {
                 if (resultElements[i] != expectedValues[i])
                 {
-                    Succeeded = false;
+                    succeeded = false;
                     break;
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"Vector64.Create(Byte): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"   value: ({string.Join(", ", expectedValues)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", resultElements)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/General/Vector64/CreateElement.Int16.cs b/tests/src/JIT/HardwareIntrinsics/General/Vector64/CreateElement.Int16.cs
index 1081a2001a73..6ecb7f0fa78a 100644
--- a/tests/src/JIT/HardwareIntrinsics/General/Vector64/CreateElement.Int16.cs
+++ b/tests/src/JIT/HardwareIntrinsics/General/Vector64/CreateElement.Int16.cs
@@ -88,21 +88,25 @@ private void ValidateResult(Vector64<Int16> result, Int16[] expectedValues, [Cal
 
         private void ValidateResult(Int16[] resultElements, Int16[] expectedValues, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             for (var i = 0; i < ElementCount; i++)
             {
                 if (resultElements[i] != expectedValues[i])
                 {
-                    Succeeded = false;
+                    succeeded = false;
                     break;
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"Vector64.Create(Int16): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"   value: ({string.Join(", ", expectedValues)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", resultElements)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/General/Vector64/CreateElement.Int32.cs b/tests/src/JIT/HardwareIntrinsics/General/Vector64/CreateElement.Int32.cs
index ee4c0e594cf7..709d278c77d0 100644
--- a/tests/src/JIT/HardwareIntrinsics/General/Vector64/CreateElement.Int32.cs
+++ b/tests/src/JIT/HardwareIntrinsics/General/Vector64/CreateElement.Int32.cs
@@ -88,21 +88,25 @@ private void ValidateResult(Vector64<Int32> result, Int32[] expectedValues, [Cal
 
         private void ValidateResult(Int32[] resultElements, Int32[] expectedValues, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             for (var i = 0; i < ElementCount; i++)
             {
                 if (resultElements[i] != expectedValues[i])
                 {
-                    Succeeded = false;
+                    succeeded = false;
                     break;
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"Vector64.Create(Int32): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"   value: ({string.Join(", ", expectedValues)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", resultElements)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/General/Vector64/CreateElement.SByte.cs b/tests/src/JIT/HardwareIntrinsics/General/Vector64/CreateElement.SByte.cs
index fbd75dd7423d..ab43b16c0cbb 100644
--- a/tests/src/JIT/HardwareIntrinsics/General/Vector64/CreateElement.SByte.cs
+++ b/tests/src/JIT/HardwareIntrinsics/General/Vector64/CreateElement.SByte.cs
@@ -88,21 +88,25 @@ private void ValidateResult(Vector64<SByte> result, SByte[] expectedValues, [Cal
 
         private void ValidateResult(SByte[] resultElements, SByte[] expectedValues, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             for (var i = 0; i < ElementCount; i++)
             {
                 if (resultElements[i] != expectedValues[i])
                 {
-                    Succeeded = false;
+                    succeeded = false;
                     break;
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"Vector64.Create(SByte): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"   value: ({string.Join(", ", expectedValues)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", resultElements)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/General/Vector64/CreateElement.Single.cs b/tests/src/JIT/HardwareIntrinsics/General/Vector64/CreateElement.Single.cs
index dd0b74cfa5b4..e499386396ef 100644
--- a/tests/src/JIT/HardwareIntrinsics/General/Vector64/CreateElement.Single.cs
+++ b/tests/src/JIT/HardwareIntrinsics/General/Vector64/CreateElement.Single.cs
@@ -88,21 +88,25 @@ private void ValidateResult(Vector64<Single> result, Single[] expectedValues, [C
 
         private void ValidateResult(Single[] resultElements, Single[] expectedValues, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             for (var i = 0; i < ElementCount; i++)
             {
                 if (resultElements[i] != expectedValues[i])
                 {
-                    Succeeded = false;
+                    succeeded = false;
                     break;
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"Vector64.Create(Single): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"   value: ({string.Join(", ", expectedValues)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", resultElements)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/General/Vector64/CreateElement.UInt16.cs b/tests/src/JIT/HardwareIntrinsics/General/Vector64/CreateElement.UInt16.cs
index 2f171857e1f7..824b9ef3af01 100644
--- a/tests/src/JIT/HardwareIntrinsics/General/Vector64/CreateElement.UInt16.cs
+++ b/tests/src/JIT/HardwareIntrinsics/General/Vector64/CreateElement.UInt16.cs
@@ -88,21 +88,25 @@ private void ValidateResult(Vector64<UInt16> result, UInt16[] expectedValues, [C
 
         private void ValidateResult(UInt16[] resultElements, UInt16[] expectedValues, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             for (var i = 0; i < ElementCount; i++)
             {
                 if (resultElements[i] != expectedValues[i])
                 {
-                    Succeeded = false;
+                    succeeded = false;
                     break;
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"Vector64.Create(UInt16): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"   value: ({string.Join(", ", expectedValues)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", resultElements)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/General/Vector64/CreateElement.UInt32.cs b/tests/src/JIT/HardwareIntrinsics/General/Vector64/CreateElement.UInt32.cs
index dae04a3de7da..0c70328d8a68 100644
--- a/tests/src/JIT/HardwareIntrinsics/General/Vector64/CreateElement.UInt32.cs
+++ b/tests/src/JIT/HardwareIntrinsics/General/Vector64/CreateElement.UInt32.cs
@@ -88,21 +88,25 @@ private void ValidateResult(Vector64<UInt32> result, UInt32[] expectedValues, [C
 
         private void ValidateResult(UInt32[] resultElements, UInt32[] expectedValues, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             for (var i = 0; i < ElementCount; i++)
             {
                 if (resultElements[i] != expectedValues[i])
                 {
-                    Succeeded = false;
+                    succeeded = false;
                     break;
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"Vector64.Create(UInt32): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"   value: ({string.Join(", ", expectedValues)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", resultElements)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/General/Vector64/CreateScalar.Byte.cs b/tests/src/JIT/HardwareIntrinsics/General/Vector64/CreateScalar.Byte.cs
index d57e7e9d1a7f..36a8c8ef046a 100644
--- a/tests/src/JIT/HardwareIntrinsics/General/Vector64/CreateScalar.Byte.cs
+++ b/tests/src/JIT/HardwareIntrinsics/General/Vector64/CreateScalar.Byte.cs
@@ -74,9 +74,11 @@ private void ValidateResult(Vector64<Byte> result, Byte expectedValue, [CallerMe
 
         private void ValidateResult(Byte[] resultElements, Byte expectedValue, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (resultElements[0] != expectedValue)
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -84,18 +86,20 @@ private void ValidateResult(Byte[] resultElements, Byte expectedValue, [CallerMe
                 {
                     if (resultElements[i] != 0)
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"Vector64.CreateScalar(Byte): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"   value: {expectedValue}");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", resultElements)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/General/Vector64/CreateScalar.Int16.cs b/tests/src/JIT/HardwareIntrinsics/General/Vector64/CreateScalar.Int16.cs
index ff5cc9f5cab8..5076cd40415c 100644
--- a/tests/src/JIT/HardwareIntrinsics/General/Vector64/CreateScalar.Int16.cs
+++ b/tests/src/JIT/HardwareIntrinsics/General/Vector64/CreateScalar.Int16.cs
@@ -74,9 +74,11 @@ private void ValidateResult(Vector64<Int16> result, Int16 expectedValue, [Caller
 
         private void ValidateResult(Int16[] resultElements, Int16 expectedValue, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (resultElements[0] != expectedValue)
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -84,18 +86,20 @@ private void ValidateResult(Int16[] resultElements, Int16 expectedValue, [Caller
                 {
                     if (resultElements[i] != 0)
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"Vector64.CreateScalar(Int16): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"   value: {expectedValue}");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", resultElements)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/General/Vector64/CreateScalar.Int32.cs b/tests/src/JIT/HardwareIntrinsics/General/Vector64/CreateScalar.Int32.cs
index ee8a0618e96e..6fbe11792128 100644
--- a/tests/src/JIT/HardwareIntrinsics/General/Vector64/CreateScalar.Int32.cs
+++ b/tests/src/JIT/HardwareIntrinsics/General/Vector64/CreateScalar.Int32.cs
@@ -74,9 +74,11 @@ private void ValidateResult(Vector64<Int32> result, Int32 expectedValue, [Caller
 
         private void ValidateResult(Int32[] resultElements, Int32 expectedValue, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (resultElements[0] != expectedValue)
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -84,18 +86,20 @@ private void ValidateResult(Int32[] resultElements, Int32 expectedValue, [Caller
                 {
                     if (resultElements[i] != 0)
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"Vector64.CreateScalar(Int32): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"   value: {expectedValue}");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", resultElements)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/General/Vector64/CreateScalar.SByte.cs b/tests/src/JIT/HardwareIntrinsics/General/Vector64/CreateScalar.SByte.cs
index 691a8486ce93..fbd0fae93824 100644
--- a/tests/src/JIT/HardwareIntrinsics/General/Vector64/CreateScalar.SByte.cs
+++ b/tests/src/JIT/HardwareIntrinsics/General/Vector64/CreateScalar.SByte.cs
@@ -74,9 +74,11 @@ private void ValidateResult(Vector64<SByte> result, SByte expectedValue, [Caller
 
         private void ValidateResult(SByte[] resultElements, SByte expectedValue, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (resultElements[0] != expectedValue)
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -84,18 +86,20 @@ private void ValidateResult(SByte[] resultElements, SByte expectedValue, [Caller
                 {
                     if (resultElements[i] != 0)
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"Vector64.CreateScalar(SByte): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"   value: {expectedValue}");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", resultElements)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/General/Vector64/CreateScalar.Single.cs b/tests/src/JIT/HardwareIntrinsics/General/Vector64/CreateScalar.Single.cs
index d0005554b3b5..568ede828f38 100644
--- a/tests/src/JIT/HardwareIntrinsics/General/Vector64/CreateScalar.Single.cs
+++ b/tests/src/JIT/HardwareIntrinsics/General/Vector64/CreateScalar.Single.cs
@@ -74,9 +74,11 @@ private void ValidateResult(Vector64<Single> result, Single expectedValue, [Call
 
         private void ValidateResult(Single[] resultElements, Single expectedValue, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (resultElements[0] != expectedValue)
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -84,18 +86,20 @@ private void ValidateResult(Single[] resultElements, Single expectedValue, [Call
                 {
                     if (resultElements[i] != 0)
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"Vector64.CreateScalar(Single): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"   value: {expectedValue}");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", resultElements)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/General/Vector64/CreateScalar.UInt16.cs b/tests/src/JIT/HardwareIntrinsics/General/Vector64/CreateScalar.UInt16.cs
index 6fc0ea914bc4..7ad7417acd97 100644
--- a/tests/src/JIT/HardwareIntrinsics/General/Vector64/CreateScalar.UInt16.cs
+++ b/tests/src/JIT/HardwareIntrinsics/General/Vector64/CreateScalar.UInt16.cs
@@ -74,9 +74,11 @@ private void ValidateResult(Vector64<UInt16> result, UInt16 expectedValue, [Call
 
         private void ValidateResult(UInt16[] resultElements, UInt16 expectedValue, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (resultElements[0] != expectedValue)
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -84,18 +86,20 @@ private void ValidateResult(UInt16[] resultElements, UInt16 expectedValue, [Call
                 {
                     if (resultElements[i] != 0)
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"Vector64.CreateScalar(UInt16): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"   value: {expectedValue}");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", resultElements)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/General/Vector64/CreateScalar.UInt32.cs b/tests/src/JIT/HardwareIntrinsics/General/Vector64/CreateScalar.UInt32.cs
index 39078e0e7c1b..e42c4959c40b 100644
--- a/tests/src/JIT/HardwareIntrinsics/General/Vector64/CreateScalar.UInt32.cs
+++ b/tests/src/JIT/HardwareIntrinsics/General/Vector64/CreateScalar.UInt32.cs
@@ -74,9 +74,11 @@ private void ValidateResult(Vector64<UInt32> result, UInt32 expectedValue, [Call
 
         private void ValidateResult(UInt32[] resultElements, UInt32 expectedValue, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (resultElements[0] != expectedValue)
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -84,18 +86,20 @@ private void ValidateResult(UInt32[] resultElements, UInt32 expectedValue, [Call
                 {
                     if (resultElements[i] != 0)
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"Vector64.CreateScalar(UInt32): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"   value: {expectedValue}");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", resultElements)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/General/Vector64/CreateScalarUnsafe.Byte.cs b/tests/src/JIT/HardwareIntrinsics/General/Vector64/CreateScalarUnsafe.Byte.cs
index d4222d9e807a..29cf288e8a4d 100644
--- a/tests/src/JIT/HardwareIntrinsics/General/Vector64/CreateScalarUnsafe.Byte.cs
+++ b/tests/src/JIT/HardwareIntrinsics/General/Vector64/CreateScalarUnsafe.Byte.cs
@@ -74,9 +74,11 @@ private void ValidateResult(Vector64<Byte> result, Byte expectedValue, [CallerMe
 
         private void ValidateResult(Byte[] resultElements, Byte expectedValue, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (resultElements[0] != expectedValue)
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -84,18 +86,20 @@ private void ValidateResult(Byte[] resultElements, Byte expectedValue, [CallerMe
                 {
                     if (false /* value is uninitialized */)
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"Vector64.CreateScalarUnsafe(Byte): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"   value: {expectedValue}");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", resultElements)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/General/Vector64/CreateScalarUnsafe.Int16.cs b/tests/src/JIT/HardwareIntrinsics/General/Vector64/CreateScalarUnsafe.Int16.cs
index b49c4a99fa5d..6b0f75918a7b 100644
--- a/tests/src/JIT/HardwareIntrinsics/General/Vector64/CreateScalarUnsafe.Int16.cs
+++ b/tests/src/JIT/HardwareIntrinsics/General/Vector64/CreateScalarUnsafe.Int16.cs
@@ -74,9 +74,11 @@ private void ValidateResult(Vector64<Int16> result, Int16 expectedValue, [Caller
 
         private void ValidateResult(Int16[] resultElements, Int16 expectedValue, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (resultElements[0] != expectedValue)
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -84,18 +86,20 @@ private void ValidateResult(Int16[] resultElements, Int16 expectedValue, [Caller
                 {
                     if (false /* value is uninitialized */)
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"Vector64.CreateScalarUnsafe(Int16): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"   value: {expectedValue}");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", resultElements)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/General/Vector64/CreateScalarUnsafe.Int32.cs b/tests/src/JIT/HardwareIntrinsics/General/Vector64/CreateScalarUnsafe.Int32.cs
index 0e4f34d6c884..1a519eb10e80 100644
--- a/tests/src/JIT/HardwareIntrinsics/General/Vector64/CreateScalarUnsafe.Int32.cs
+++ b/tests/src/JIT/HardwareIntrinsics/General/Vector64/CreateScalarUnsafe.Int32.cs
@@ -74,9 +74,11 @@ private void ValidateResult(Vector64<Int32> result, Int32 expectedValue, [Caller
 
         private void ValidateResult(Int32[] resultElements, Int32 expectedValue, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (resultElements[0] != expectedValue)
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -84,18 +86,20 @@ private void ValidateResult(Int32[] resultElements, Int32 expectedValue, [Caller
                 {
                     if (false /* value is uninitialized */)
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"Vector64.CreateScalarUnsafe(Int32): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"   value: {expectedValue}");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", resultElements)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/General/Vector64/CreateScalarUnsafe.SByte.cs b/tests/src/JIT/HardwareIntrinsics/General/Vector64/CreateScalarUnsafe.SByte.cs
index 052a77d08009..97331288a453 100644
--- a/tests/src/JIT/HardwareIntrinsics/General/Vector64/CreateScalarUnsafe.SByte.cs
+++ b/tests/src/JIT/HardwareIntrinsics/General/Vector64/CreateScalarUnsafe.SByte.cs
@@ -74,9 +74,11 @@ private void ValidateResult(Vector64<SByte> result, SByte expectedValue, [Caller
 
         private void ValidateResult(SByte[] resultElements, SByte expectedValue, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (resultElements[0] != expectedValue)
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -84,18 +86,20 @@ private void ValidateResult(SByte[] resultElements, SByte expectedValue, [Caller
                 {
                     if (false /* value is uninitialized */)
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"Vector64.CreateScalarUnsafe(SByte): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"   value: {expectedValue}");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", resultElements)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/General/Vector64/CreateScalarUnsafe.Single.cs b/tests/src/JIT/HardwareIntrinsics/General/Vector64/CreateScalarUnsafe.Single.cs
index 236a12c74afc..c2ecc66ee6d0 100644
--- a/tests/src/JIT/HardwareIntrinsics/General/Vector64/CreateScalarUnsafe.Single.cs
+++ b/tests/src/JIT/HardwareIntrinsics/General/Vector64/CreateScalarUnsafe.Single.cs
@@ -74,9 +74,11 @@ private void ValidateResult(Vector64<Single> result, Single expectedValue, [Call
 
         private void ValidateResult(Single[] resultElements, Single expectedValue, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (resultElements[0] != expectedValue)
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -84,18 +86,20 @@ private void ValidateResult(Single[] resultElements, Single expectedValue, [Call
                 {
                     if (false /* value is uninitialized */)
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"Vector64.CreateScalarUnsafe(Single): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"   value: {expectedValue}");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", resultElements)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/General/Vector64/CreateScalarUnsafe.UInt16.cs b/tests/src/JIT/HardwareIntrinsics/General/Vector64/CreateScalarUnsafe.UInt16.cs
index 31ed850d5a55..53df941a244f 100644
--- a/tests/src/JIT/HardwareIntrinsics/General/Vector64/CreateScalarUnsafe.UInt16.cs
+++ b/tests/src/JIT/HardwareIntrinsics/General/Vector64/CreateScalarUnsafe.UInt16.cs
@@ -74,9 +74,11 @@ private void ValidateResult(Vector64<UInt16> result, UInt16 expectedValue, [Call
 
         private void ValidateResult(UInt16[] resultElements, UInt16 expectedValue, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (resultElements[0] != expectedValue)
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -84,18 +86,20 @@ private void ValidateResult(UInt16[] resultElements, UInt16 expectedValue, [Call
                 {
                     if (false /* value is uninitialized */)
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"Vector64.CreateScalarUnsafe(UInt16): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"   value: {expectedValue}");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", resultElements)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/General/Vector64/CreateScalarUnsafe.UInt32.cs b/tests/src/JIT/HardwareIntrinsics/General/Vector64/CreateScalarUnsafe.UInt32.cs
index 151cf897c787..1ae6773460d0 100644
--- a/tests/src/JIT/HardwareIntrinsics/General/Vector64/CreateScalarUnsafe.UInt32.cs
+++ b/tests/src/JIT/HardwareIntrinsics/General/Vector64/CreateScalarUnsafe.UInt32.cs
@@ -74,9 +74,11 @@ private void ValidateResult(Vector64<UInt32> result, UInt32 expectedValue, [Call
 
         private void ValidateResult(UInt32[] resultElements, UInt32 expectedValue, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (resultElements[0] != expectedValue)
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -84,18 +86,20 @@ private void ValidateResult(UInt32[] resultElements, UInt32 expectedValue, [Call
                 {
                     if (false /* value is uninitialized */)
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"Vector64.CreateScalarUnsafe(UInt32): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"   value: {expectedValue}");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", resultElements)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/General/Vector64_1/As.Byte.cs b/tests/src/JIT/HardwareIntrinsics/General/Vector64_1/As.Byte.cs
index 6eac65c18dc3..ea274614e5e6 100644
--- a/tests/src/JIT/HardwareIntrinsics/General/Vector64_1/As.Byte.cs
+++ b/tests/src/JIT/HardwareIntrinsics/General/Vector64_1/As.Byte.cs
@@ -218,21 +218,25 @@ private void ValidateResult<T>(Vector64<T> result, Vector64<Byte> value, [Caller
 
         private void ValidateResult(Byte[] resultElements, Byte[] valueElements, Type targetType, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             for (var i = 0; i < ElementCount; i++)
             {
                 if (resultElements[i] != valueElements[i])
                 {
-                    Succeeded = false;
+                    succeeded = false;
                     break;
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"Vector64<Byte>.As{targetType.Name}: {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"   value: ({string.Join(", ", valueElements)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", resultElements)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/General/Vector64_1/As.Double.cs b/tests/src/JIT/HardwareIntrinsics/General/Vector64_1/As.Double.cs
index 5049d3bf1919..d3b267544dd5 100644
--- a/tests/src/JIT/HardwareIntrinsics/General/Vector64_1/As.Double.cs
+++ b/tests/src/JIT/HardwareIntrinsics/General/Vector64_1/As.Double.cs
@@ -218,21 +218,25 @@ private void ValidateResult<T>(Vector64<T> result, Vector64<Double> value, [Call
 
         private void ValidateResult(Double[] resultElements, Double[] valueElements, Type targetType, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             for (var i = 0; i < ElementCount; i++)
             {
                 if (resultElements[i] != valueElements[i])
                 {
-                    Succeeded = false;
+                    succeeded = false;
                     break;
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"Vector64<Double>.As{targetType.Name}: {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"   value: ({string.Join(", ", valueElements)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", resultElements)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/General/Vector64_1/As.Int16.cs b/tests/src/JIT/HardwareIntrinsics/General/Vector64_1/As.Int16.cs
index 277f19bfb0c9..c79a06bfb61f 100644
--- a/tests/src/JIT/HardwareIntrinsics/General/Vector64_1/As.Int16.cs
+++ b/tests/src/JIT/HardwareIntrinsics/General/Vector64_1/As.Int16.cs
@@ -218,21 +218,25 @@ private void ValidateResult<T>(Vector64<T> result, Vector64<Int16> value, [Calle
 
         private void ValidateResult(Int16[] resultElements, Int16[] valueElements, Type targetType, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             for (var i = 0; i < ElementCount; i++)
             {
                 if (resultElements[i] != valueElements[i])
                 {
-                    Succeeded = false;
+                    succeeded = false;
                     break;
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"Vector64<Int16>.As{targetType.Name}: {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"   value: ({string.Join(", ", valueElements)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", resultElements)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/General/Vector64_1/As.Int32.cs b/tests/src/JIT/HardwareIntrinsics/General/Vector64_1/As.Int32.cs
index 2e84dc7288c7..dfe904446885 100644
--- a/tests/src/JIT/HardwareIntrinsics/General/Vector64_1/As.Int32.cs
+++ b/tests/src/JIT/HardwareIntrinsics/General/Vector64_1/As.Int32.cs
@@ -218,21 +218,25 @@ private void ValidateResult<T>(Vector64<T> result, Vector64<Int32> value, [Calle
 
         private void ValidateResult(Int32[] resultElements, Int32[] valueElements, Type targetType, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             for (var i = 0; i < ElementCount; i++)
             {
                 if (resultElements[i] != valueElements[i])
                 {
-                    Succeeded = false;
+                    succeeded = false;
                     break;
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"Vector64<Int32>.As{targetType.Name}: {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"   value: ({string.Join(", ", valueElements)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", resultElements)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/General/Vector64_1/As.Int64.cs b/tests/src/JIT/HardwareIntrinsics/General/Vector64_1/As.Int64.cs
index 360383c0e60a..3891e231f0d4 100644
--- a/tests/src/JIT/HardwareIntrinsics/General/Vector64_1/As.Int64.cs
+++ b/tests/src/JIT/HardwareIntrinsics/General/Vector64_1/As.Int64.cs
@@ -218,21 +218,25 @@ private void ValidateResult<T>(Vector64<T> result, Vector64<Int64> value, [Calle
 
         private void ValidateResult(Int64[] resultElements, Int64[] valueElements, Type targetType, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             for (var i = 0; i < ElementCount; i++)
             {
                 if (resultElements[i] != valueElements[i])
                 {
-                    Succeeded = false;
+                    succeeded = false;
                     break;
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"Vector64<Int64>.As{targetType.Name}: {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"   value: ({string.Join(", ", valueElements)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", resultElements)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/General/Vector64_1/As.SByte.cs b/tests/src/JIT/HardwareIntrinsics/General/Vector64_1/As.SByte.cs
index 07e52573b775..e12177011e9b 100644
--- a/tests/src/JIT/HardwareIntrinsics/General/Vector64_1/As.SByte.cs
+++ b/tests/src/JIT/HardwareIntrinsics/General/Vector64_1/As.SByte.cs
@@ -218,21 +218,25 @@ private void ValidateResult<T>(Vector64<T> result, Vector64<SByte> value, [Calle
 
         private void ValidateResult(SByte[] resultElements, SByte[] valueElements, Type targetType, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             for (var i = 0; i < ElementCount; i++)
             {
                 if (resultElements[i] != valueElements[i])
                 {
-                    Succeeded = false;
+                    succeeded = false;
                     break;
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"Vector64<SByte>.As{targetType.Name}: {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"   value: ({string.Join(", ", valueElements)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", resultElements)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/General/Vector64_1/As.Single.cs b/tests/src/JIT/HardwareIntrinsics/General/Vector64_1/As.Single.cs
index 09e2032183b0..55a63a640028 100644
--- a/tests/src/JIT/HardwareIntrinsics/General/Vector64_1/As.Single.cs
+++ b/tests/src/JIT/HardwareIntrinsics/General/Vector64_1/As.Single.cs
@@ -218,21 +218,25 @@ private void ValidateResult<T>(Vector64<T> result, Vector64<Single> value, [Call
 
         private void ValidateResult(Single[] resultElements, Single[] valueElements, Type targetType, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             for (var i = 0; i < ElementCount; i++)
             {
                 if (resultElements[i] != valueElements[i])
                 {
-                    Succeeded = false;
+                    succeeded = false;
                     break;
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"Vector64<Single>.As{targetType.Name}: {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"   value: ({string.Join(", ", valueElements)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", resultElements)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/General/Vector64_1/As.UInt16.cs b/tests/src/JIT/HardwareIntrinsics/General/Vector64_1/As.UInt16.cs
index 98eb0bd30694..de6c8c2e06a4 100644
--- a/tests/src/JIT/HardwareIntrinsics/General/Vector64_1/As.UInt16.cs
+++ b/tests/src/JIT/HardwareIntrinsics/General/Vector64_1/As.UInt16.cs
@@ -218,21 +218,25 @@ private void ValidateResult<T>(Vector64<T> result, Vector64<UInt16> value, [Call
 
         private void ValidateResult(UInt16[] resultElements, UInt16[] valueElements, Type targetType, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             for (var i = 0; i < ElementCount; i++)
             {
                 if (resultElements[i] != valueElements[i])
                 {
-                    Succeeded = false;
+                    succeeded = false;
                     break;
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"Vector64<UInt16>.As{targetType.Name}: {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"   value: ({string.Join(", ", valueElements)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", resultElements)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/General/Vector64_1/As.UInt32.cs b/tests/src/JIT/HardwareIntrinsics/General/Vector64_1/As.UInt32.cs
index cc18b72d5f5b..6d77b587063c 100644
--- a/tests/src/JIT/HardwareIntrinsics/General/Vector64_1/As.UInt32.cs
+++ b/tests/src/JIT/HardwareIntrinsics/General/Vector64_1/As.UInt32.cs
@@ -218,21 +218,25 @@ private void ValidateResult<T>(Vector64<T> result, Vector64<UInt32> value, [Call
 
         private void ValidateResult(UInt32[] resultElements, UInt32[] valueElements, Type targetType, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             for (var i = 0; i < ElementCount; i++)
             {
                 if (resultElements[i] != valueElements[i])
                 {
-                    Succeeded = false;
+                    succeeded = false;
                     break;
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"Vector64<UInt32>.As{targetType.Name}: {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"   value: ({string.Join(", ", valueElements)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", resultElements)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/General/Vector64_1/As.UInt64.cs b/tests/src/JIT/HardwareIntrinsics/General/Vector64_1/As.UInt64.cs
index 0be567528d34..03af43f1841e 100644
--- a/tests/src/JIT/HardwareIntrinsics/General/Vector64_1/As.UInt64.cs
+++ b/tests/src/JIT/HardwareIntrinsics/General/Vector64_1/As.UInt64.cs
@@ -218,21 +218,25 @@ private void ValidateResult<T>(Vector64<T> result, Vector64<UInt64> value, [Call
 
         private void ValidateResult(UInt64[] resultElements, UInt64[] valueElements, Type targetType, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             for (var i = 0; i < ElementCount; i++)
             {
                 if (resultElements[i] != valueElements[i])
                 {
-                    Succeeded = false;
+                    succeeded = false;
                     break;
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"Vector64<UInt64>.As{targetType.Name}: {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"   value: ({string.Join(", ", valueElements)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", resultElements)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/General/Vector64_1/GetAndWithElement.Byte.0.cs b/tests/src/JIT/HardwareIntrinsics/General/Vector64_1/GetAndWithElement.Byte.0.cs
index 2295b088e381..139da253645d 100644
--- a/tests/src/JIT/HardwareIntrinsics/General/Vector64_1/GetAndWithElement.Byte.0.cs
+++ b/tests/src/JIT/HardwareIntrinsics/General/Vector64_1/GetAndWithElement.Byte.0.cs
@@ -74,10 +74,10 @@ public void RunBasicScenario(int imm = 0, bool expectedOutOfRangeException = fal
 
             if (!succeeded)
             {
-                Succeeded = false;
-
                 TestLibrary.TestFramework.LogInformation($"Vector64<Byte.GetElement({imm}): {nameof(RunBasicScenario)} failed to throw ArgumentOutOfRangeException.");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
 
             succeeded = !expectedOutOfRangeException;
@@ -96,10 +96,10 @@ public void RunBasicScenario(int imm = 0, bool expectedOutOfRangeException = fal
 
             if (!succeeded)
             {
-                Succeeded = false;
-
                 TestLibrary.TestFramework.LogInformation($"Vector64<Byte.WithElement({imm}): {nameof(RunBasicScenario)} failed to throw ArgumentOutOfRangeException.");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
 
@@ -133,10 +133,10 @@ public void RunReflectionScenario(int imm = 0, bool expectedOutOfRangeException
 
             if (!succeeded)
             {
-                Succeeded = false;
-
                 TestLibrary.TestFramework.LogInformation($"Vector64<Byte.GetElement({imm}): {nameof(RunReflectionScenario)} failed to throw ArgumentOutOfRangeException.");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
 
             succeeded = !expectedOutOfRangeException;
@@ -158,10 +158,10 @@ public void RunReflectionScenario(int imm = 0, bool expectedOutOfRangeException
 
             if (!succeeded)
             {
-                Succeeded = false;
-
                 TestLibrary.TestFramework.LogInformation($"Vector64<Byte.WithElement({imm}): {nameof(RunReflectionScenario)} failed to throw ArgumentOutOfRangeException.");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
 
@@ -196,27 +196,31 @@ private void ValidateWithResult(Vector64<Byte> result, Byte[] values, Byte inser
 
         private void ValidateWithResult(Byte[] result, Byte[] values, Byte insertedValue, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             for (int i = 0; i < ElementCount; i++)
             {
                 if ((i != 0) && (result[i] != values[i]))
                 {
-                    Succeeded = false;
+                    succeeded = false;
                     break;
                 }
             }
 
             if (result[0] != insertedValue)
             {
-                Succeeded = false;
+                succeeded = false;
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"Vector64<Byte.WithElement(0): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"   value: ({string.Join(", ", values)})");
                 TestLibrary.TestFramework.LogInformation($"  insert: insertedValue");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/General/Vector64_1/GetAndWithElement.Byte.7.cs b/tests/src/JIT/HardwareIntrinsics/General/Vector64_1/GetAndWithElement.Byte.7.cs
index 7a087a59157c..515c760ec303 100644
--- a/tests/src/JIT/HardwareIntrinsics/General/Vector64_1/GetAndWithElement.Byte.7.cs
+++ b/tests/src/JIT/HardwareIntrinsics/General/Vector64_1/GetAndWithElement.Byte.7.cs
@@ -74,10 +74,10 @@ public void RunBasicScenario(int imm = 7, bool expectedOutOfRangeException = fal
 
             if (!succeeded)
             {
-                Succeeded = false;
-
                 TestLibrary.TestFramework.LogInformation($"Vector64<Byte.GetElement({imm}): {nameof(RunBasicScenario)} failed to throw ArgumentOutOfRangeException.");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
 
             succeeded = !expectedOutOfRangeException;
@@ -96,10 +96,10 @@ public void RunBasicScenario(int imm = 7, bool expectedOutOfRangeException = fal
 
             if (!succeeded)
             {
-                Succeeded = false;
-
                 TestLibrary.TestFramework.LogInformation($"Vector64<Byte.WithElement({imm}): {nameof(RunBasicScenario)} failed to throw ArgumentOutOfRangeException.");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
 
@@ -133,10 +133,10 @@ public void RunReflectionScenario(int imm = 7, bool expectedOutOfRangeException
 
             if (!succeeded)
             {
-                Succeeded = false;
-
                 TestLibrary.TestFramework.LogInformation($"Vector64<Byte.GetElement({imm}): {nameof(RunReflectionScenario)} failed to throw ArgumentOutOfRangeException.");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
 
             succeeded = !expectedOutOfRangeException;
@@ -158,10 +158,10 @@ public void RunReflectionScenario(int imm = 7, bool expectedOutOfRangeException
 
             if (!succeeded)
             {
-                Succeeded = false;
-
                 TestLibrary.TestFramework.LogInformation($"Vector64<Byte.WithElement({imm}): {nameof(RunReflectionScenario)} failed to throw ArgumentOutOfRangeException.");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
 
@@ -196,27 +196,31 @@ private void ValidateWithResult(Vector64<Byte> result, Byte[] values, Byte inser
 
         private void ValidateWithResult(Byte[] result, Byte[] values, Byte insertedValue, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             for (int i = 0; i < ElementCount; i++)
             {
                 if ((i != 7) && (result[i] != values[i]))
                 {
-                    Succeeded = false;
+                    succeeded = false;
                     break;
                 }
             }
 
             if (result[7] != insertedValue)
             {
-                Succeeded = false;
+                succeeded = false;
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"Vector64<Byte.WithElement(7): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"   value: ({string.Join(", ", values)})");
                 TestLibrary.TestFramework.LogInformation($"  insert: insertedValue");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/General/Vector64_1/GetAndWithElement.Double.0.cs b/tests/src/JIT/HardwareIntrinsics/General/Vector64_1/GetAndWithElement.Double.0.cs
index 55a0f8021f83..0208df4448a9 100644
--- a/tests/src/JIT/HardwareIntrinsics/General/Vector64_1/GetAndWithElement.Double.0.cs
+++ b/tests/src/JIT/HardwareIntrinsics/General/Vector64_1/GetAndWithElement.Double.0.cs
@@ -74,10 +74,10 @@ public void RunBasicScenario(int imm = 0, bool expectedOutOfRangeException = fal
 
             if (!succeeded)
             {
-                Succeeded = false;
-
                 TestLibrary.TestFramework.LogInformation($"Vector64<Double.GetElement({imm}): {nameof(RunBasicScenario)} failed to throw ArgumentOutOfRangeException.");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
 
             succeeded = !expectedOutOfRangeException;
@@ -96,10 +96,10 @@ public void RunBasicScenario(int imm = 0, bool expectedOutOfRangeException = fal
 
             if (!succeeded)
             {
-                Succeeded = false;
-
                 TestLibrary.TestFramework.LogInformation($"Vector64<Double.WithElement({imm}): {nameof(RunBasicScenario)} failed to throw ArgumentOutOfRangeException.");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
 
@@ -133,10 +133,10 @@ public void RunReflectionScenario(int imm = 0, bool expectedOutOfRangeException
 
             if (!succeeded)
             {
-                Succeeded = false;
-
                 TestLibrary.TestFramework.LogInformation($"Vector64<Double.GetElement({imm}): {nameof(RunReflectionScenario)} failed to throw ArgumentOutOfRangeException.");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
 
             succeeded = !expectedOutOfRangeException;
@@ -158,10 +158,10 @@ public void RunReflectionScenario(int imm = 0, bool expectedOutOfRangeException
 
             if (!succeeded)
             {
-                Succeeded = false;
-
                 TestLibrary.TestFramework.LogInformation($"Vector64<Double.WithElement({imm}): {nameof(RunReflectionScenario)} failed to throw ArgumentOutOfRangeException.");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
 
@@ -196,27 +196,31 @@ private void ValidateWithResult(Vector64<Double> result, Double[] values, Double
 
         private void ValidateWithResult(Double[] result, Double[] values, Double insertedValue, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             for (int i = 0; i < ElementCount; i++)
             {
                 if ((i != 0) && (result[i] != values[i]))
                 {
-                    Succeeded = false;
+                    succeeded = false;
                     break;
                 }
             }
 
             if (result[0] != insertedValue)
             {
-                Succeeded = false;
+                succeeded = false;
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"Vector64<Double.WithElement(0): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"   value: ({string.Join(", ", values)})");
                 TestLibrary.TestFramework.LogInformation($"  insert: insertedValue");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/General/Vector64_1/GetAndWithElement.Int16.0.cs b/tests/src/JIT/HardwareIntrinsics/General/Vector64_1/GetAndWithElement.Int16.0.cs
index 56f9f260eabf..3fcd947c4c7b 100644
--- a/tests/src/JIT/HardwareIntrinsics/General/Vector64_1/GetAndWithElement.Int16.0.cs
+++ b/tests/src/JIT/HardwareIntrinsics/General/Vector64_1/GetAndWithElement.Int16.0.cs
@@ -74,10 +74,10 @@ public void RunBasicScenario(int imm = 0, bool expectedOutOfRangeException = fal
 
             if (!succeeded)
             {
-                Succeeded = false;
-
                 TestLibrary.TestFramework.LogInformation($"Vector64<Int16.GetElement({imm}): {nameof(RunBasicScenario)} failed to throw ArgumentOutOfRangeException.");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
 
             succeeded = !expectedOutOfRangeException;
@@ -96,10 +96,10 @@ public void RunBasicScenario(int imm = 0, bool expectedOutOfRangeException = fal
 
             if (!succeeded)
             {
-                Succeeded = false;
-
                 TestLibrary.TestFramework.LogInformation($"Vector64<Int16.WithElement({imm}): {nameof(RunBasicScenario)} failed to throw ArgumentOutOfRangeException.");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
 
@@ -133,10 +133,10 @@ public void RunReflectionScenario(int imm = 0, bool expectedOutOfRangeException
 
             if (!succeeded)
             {
-                Succeeded = false;
-
                 TestLibrary.TestFramework.LogInformation($"Vector64<Int16.GetElement({imm}): {nameof(RunReflectionScenario)} failed to throw ArgumentOutOfRangeException.");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
 
             succeeded = !expectedOutOfRangeException;
@@ -158,10 +158,10 @@ public void RunReflectionScenario(int imm = 0, bool expectedOutOfRangeException
 
             if (!succeeded)
             {
-                Succeeded = false;
-
                 TestLibrary.TestFramework.LogInformation($"Vector64<Int16.WithElement({imm}): {nameof(RunReflectionScenario)} failed to throw ArgumentOutOfRangeException.");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
 
@@ -196,27 +196,31 @@ private void ValidateWithResult(Vector64<Int16> result, Int16[] values, Int16 in
 
         private void ValidateWithResult(Int16[] result, Int16[] values, Int16 insertedValue, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             for (int i = 0; i < ElementCount; i++)
             {
                 if ((i != 0) && (result[i] != values[i]))
                 {
-                    Succeeded = false;
+                    succeeded = false;
                     break;
                 }
             }
 
             if (result[0] != insertedValue)
             {
-                Succeeded = false;
+                succeeded = false;
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"Vector64<Int16.WithElement(0): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"   value: ({string.Join(", ", values)})");
                 TestLibrary.TestFramework.LogInformation($"  insert: insertedValue");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/General/Vector64_1/GetAndWithElement.Int16.3.cs b/tests/src/JIT/HardwareIntrinsics/General/Vector64_1/GetAndWithElement.Int16.3.cs
index 6bac04dfce8e..38af1ccde5d6 100644
--- a/tests/src/JIT/HardwareIntrinsics/General/Vector64_1/GetAndWithElement.Int16.3.cs
+++ b/tests/src/JIT/HardwareIntrinsics/General/Vector64_1/GetAndWithElement.Int16.3.cs
@@ -74,10 +74,10 @@ public void RunBasicScenario(int imm = 3, bool expectedOutOfRangeException = fal
 
             if (!succeeded)
             {
-                Succeeded = false;
-
                 TestLibrary.TestFramework.LogInformation($"Vector64<Int16.GetElement({imm}): {nameof(RunBasicScenario)} failed to throw ArgumentOutOfRangeException.");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
 
             succeeded = !expectedOutOfRangeException;
@@ -96,10 +96,10 @@ public void RunBasicScenario(int imm = 3, bool expectedOutOfRangeException = fal
 
             if (!succeeded)
             {
-                Succeeded = false;
-
                 TestLibrary.TestFramework.LogInformation($"Vector64<Int16.WithElement({imm}): {nameof(RunBasicScenario)} failed to throw ArgumentOutOfRangeException.");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
 
@@ -133,10 +133,10 @@ public void RunReflectionScenario(int imm = 3, bool expectedOutOfRangeException
 
             if (!succeeded)
             {
-                Succeeded = false;
-
                 TestLibrary.TestFramework.LogInformation($"Vector64<Int16.GetElement({imm}): {nameof(RunReflectionScenario)} failed to throw ArgumentOutOfRangeException.");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
 
             succeeded = !expectedOutOfRangeException;
@@ -158,10 +158,10 @@ public void RunReflectionScenario(int imm = 3, bool expectedOutOfRangeException
 
             if (!succeeded)
             {
-                Succeeded = false;
-
                 TestLibrary.TestFramework.LogInformation($"Vector64<Int16.WithElement({imm}): {nameof(RunReflectionScenario)} failed to throw ArgumentOutOfRangeException.");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
 
@@ -196,27 +196,31 @@ private void ValidateWithResult(Vector64<Int16> result, Int16[] values, Int16 in
 
         private void ValidateWithResult(Int16[] result, Int16[] values, Int16 insertedValue, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             for (int i = 0; i < ElementCount; i++)
             {
                 if ((i != 3) && (result[i] != values[i]))
                 {
-                    Succeeded = false;
+                    succeeded = false;
                     break;
                 }
             }
 
             if (result[3] != insertedValue)
             {
-                Succeeded = false;
+                succeeded = false;
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"Vector64<Int16.WithElement(3): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"   value: ({string.Join(", ", values)})");
                 TestLibrary.TestFramework.LogInformation($"  insert: insertedValue");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/General/Vector64_1/GetAndWithElement.Int32.0.cs b/tests/src/JIT/HardwareIntrinsics/General/Vector64_1/GetAndWithElement.Int32.0.cs
index 79cf3b5739d5..aa7301c99271 100644
--- a/tests/src/JIT/HardwareIntrinsics/General/Vector64_1/GetAndWithElement.Int32.0.cs
+++ b/tests/src/JIT/HardwareIntrinsics/General/Vector64_1/GetAndWithElement.Int32.0.cs
@@ -74,10 +74,10 @@ public void RunBasicScenario(int imm = 0, bool expectedOutOfRangeException = fal
 
             if (!succeeded)
             {
-                Succeeded = false;
-
                 TestLibrary.TestFramework.LogInformation($"Vector64<Int32.GetElement({imm}): {nameof(RunBasicScenario)} failed to throw ArgumentOutOfRangeException.");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
 
             succeeded = !expectedOutOfRangeException;
@@ -96,10 +96,10 @@ public void RunBasicScenario(int imm = 0, bool expectedOutOfRangeException = fal
 
             if (!succeeded)
             {
-                Succeeded = false;
-
                 TestLibrary.TestFramework.LogInformation($"Vector64<Int32.WithElement({imm}): {nameof(RunBasicScenario)} failed to throw ArgumentOutOfRangeException.");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
 
@@ -133,10 +133,10 @@ public void RunReflectionScenario(int imm = 0, bool expectedOutOfRangeException
 
             if (!succeeded)
             {
-                Succeeded = false;
-
                 TestLibrary.TestFramework.LogInformation($"Vector64<Int32.GetElement({imm}): {nameof(RunReflectionScenario)} failed to throw ArgumentOutOfRangeException.");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
 
             succeeded = !expectedOutOfRangeException;
@@ -158,10 +158,10 @@ public void RunReflectionScenario(int imm = 0, bool expectedOutOfRangeException
 
             if (!succeeded)
             {
-                Succeeded = false;
-
                 TestLibrary.TestFramework.LogInformation($"Vector64<Int32.WithElement({imm}): {nameof(RunReflectionScenario)} failed to throw ArgumentOutOfRangeException.");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
 
@@ -196,27 +196,31 @@ private void ValidateWithResult(Vector64<Int32> result, Int32[] values, Int32 in
 
         private void ValidateWithResult(Int32[] result, Int32[] values, Int32 insertedValue, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             for (int i = 0; i < ElementCount; i++)
             {
                 if ((i != 0) && (result[i] != values[i]))
                 {
-                    Succeeded = false;
+                    succeeded = false;
                     break;
                 }
             }
 
             if (result[0] != insertedValue)
             {
-                Succeeded = false;
+                succeeded = false;
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"Vector64<Int32.WithElement(0): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"   value: ({string.Join(", ", values)})");
                 TestLibrary.TestFramework.LogInformation($"  insert: insertedValue");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/General/Vector64_1/GetAndWithElement.Int32.1.cs b/tests/src/JIT/HardwareIntrinsics/General/Vector64_1/GetAndWithElement.Int32.1.cs
index 2c27d71c1f11..6914aec39bf5 100644
--- a/tests/src/JIT/HardwareIntrinsics/General/Vector64_1/GetAndWithElement.Int32.1.cs
+++ b/tests/src/JIT/HardwareIntrinsics/General/Vector64_1/GetAndWithElement.Int32.1.cs
@@ -74,10 +74,10 @@ public void RunBasicScenario(int imm = 1, bool expectedOutOfRangeException = fal
 
             if (!succeeded)
             {
-                Succeeded = false;
-
                 TestLibrary.TestFramework.LogInformation($"Vector64<Int32.GetElement({imm}): {nameof(RunBasicScenario)} failed to throw ArgumentOutOfRangeException.");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
 
             succeeded = !expectedOutOfRangeException;
@@ -96,10 +96,10 @@ public void RunBasicScenario(int imm = 1, bool expectedOutOfRangeException = fal
 
             if (!succeeded)
             {
-                Succeeded = false;
-
                 TestLibrary.TestFramework.LogInformation($"Vector64<Int32.WithElement({imm}): {nameof(RunBasicScenario)} failed to throw ArgumentOutOfRangeException.");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
 
@@ -133,10 +133,10 @@ public void RunReflectionScenario(int imm = 1, bool expectedOutOfRangeException
 
             if (!succeeded)
             {
-                Succeeded = false;
-
                 TestLibrary.TestFramework.LogInformation($"Vector64<Int32.GetElement({imm}): {nameof(RunReflectionScenario)} failed to throw ArgumentOutOfRangeException.");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
 
             succeeded = !expectedOutOfRangeException;
@@ -158,10 +158,10 @@ public void RunReflectionScenario(int imm = 1, bool expectedOutOfRangeException
 
             if (!succeeded)
             {
-                Succeeded = false;
-
                 TestLibrary.TestFramework.LogInformation($"Vector64<Int32.WithElement({imm}): {nameof(RunReflectionScenario)} failed to throw ArgumentOutOfRangeException.");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
 
@@ -196,27 +196,31 @@ private void ValidateWithResult(Vector64<Int32> result, Int32[] values, Int32 in
 
         private void ValidateWithResult(Int32[] result, Int32[] values, Int32 insertedValue, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             for (int i = 0; i < ElementCount; i++)
             {
                 if ((i != 1) && (result[i] != values[i]))
                 {
-                    Succeeded = false;
+                    succeeded = false;
                     break;
                 }
             }
 
             if (result[1] != insertedValue)
             {
-                Succeeded = false;
+                succeeded = false;
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"Vector64<Int32.WithElement(1): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"   value: ({string.Join(", ", values)})");
                 TestLibrary.TestFramework.LogInformation($"  insert: insertedValue");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/General/Vector64_1/GetAndWithElement.Int64.0.cs b/tests/src/JIT/HardwareIntrinsics/General/Vector64_1/GetAndWithElement.Int64.0.cs
index 9da832ff2c40..78d43c508b5d 100644
--- a/tests/src/JIT/HardwareIntrinsics/General/Vector64_1/GetAndWithElement.Int64.0.cs
+++ b/tests/src/JIT/HardwareIntrinsics/General/Vector64_1/GetAndWithElement.Int64.0.cs
@@ -74,10 +74,10 @@ public void RunBasicScenario(int imm = 0, bool expectedOutOfRangeException = fal
 
             if (!succeeded)
             {
-                Succeeded = false;
-
                 TestLibrary.TestFramework.LogInformation($"Vector64<Int64.GetElement({imm}): {nameof(RunBasicScenario)} failed to throw ArgumentOutOfRangeException.");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
 
             succeeded = !expectedOutOfRangeException;
@@ -96,10 +96,10 @@ public void RunBasicScenario(int imm = 0, bool expectedOutOfRangeException = fal
 
             if (!succeeded)
             {
-                Succeeded = false;
-
                 TestLibrary.TestFramework.LogInformation($"Vector64<Int64.WithElement({imm}): {nameof(RunBasicScenario)} failed to throw ArgumentOutOfRangeException.");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
 
@@ -133,10 +133,10 @@ public void RunReflectionScenario(int imm = 0, bool expectedOutOfRangeException
 
             if (!succeeded)
             {
-                Succeeded = false;
-
                 TestLibrary.TestFramework.LogInformation($"Vector64<Int64.GetElement({imm}): {nameof(RunReflectionScenario)} failed to throw ArgumentOutOfRangeException.");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
 
             succeeded = !expectedOutOfRangeException;
@@ -158,10 +158,10 @@ public void RunReflectionScenario(int imm = 0, bool expectedOutOfRangeException
 
             if (!succeeded)
             {
-                Succeeded = false;
-
                 TestLibrary.TestFramework.LogInformation($"Vector64<Int64.WithElement({imm}): {nameof(RunReflectionScenario)} failed to throw ArgumentOutOfRangeException.");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
 
@@ -196,27 +196,31 @@ private void ValidateWithResult(Vector64<Int64> result, Int64[] values, Int64 in
 
         private void ValidateWithResult(Int64[] result, Int64[] values, Int64 insertedValue, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             for (int i = 0; i < ElementCount; i++)
             {
                 if ((i != 0) && (result[i] != values[i]))
                 {
-                    Succeeded = false;
+                    succeeded = false;
                     break;
                 }
             }
 
             if (result[0] != insertedValue)
             {
-                Succeeded = false;
+                succeeded = false;
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"Vector64<Int64.WithElement(0): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"   value: ({string.Join(", ", values)})");
                 TestLibrary.TestFramework.LogInformation($"  insert: insertedValue");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/General/Vector64_1/GetAndWithElement.SByte.0.cs b/tests/src/JIT/HardwareIntrinsics/General/Vector64_1/GetAndWithElement.SByte.0.cs
index f65d122e9d1c..157541f76438 100644
--- a/tests/src/JIT/HardwareIntrinsics/General/Vector64_1/GetAndWithElement.SByte.0.cs
+++ b/tests/src/JIT/HardwareIntrinsics/General/Vector64_1/GetAndWithElement.SByte.0.cs
@@ -74,10 +74,10 @@ public void RunBasicScenario(int imm = 0, bool expectedOutOfRangeException = fal
 
             if (!succeeded)
             {
-                Succeeded = false;
-
                 TestLibrary.TestFramework.LogInformation($"Vector64<SByte.GetElement({imm}): {nameof(RunBasicScenario)} failed to throw ArgumentOutOfRangeException.");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
 
             succeeded = !expectedOutOfRangeException;
@@ -96,10 +96,10 @@ public void RunBasicScenario(int imm = 0, bool expectedOutOfRangeException = fal
 
             if (!succeeded)
             {
-                Succeeded = false;
-
                 TestLibrary.TestFramework.LogInformation($"Vector64<SByte.WithElement({imm}): {nameof(RunBasicScenario)} failed to throw ArgumentOutOfRangeException.");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
 
@@ -133,10 +133,10 @@ public void RunReflectionScenario(int imm = 0, bool expectedOutOfRangeException
 
             if (!succeeded)
             {
-                Succeeded = false;
-
                 TestLibrary.TestFramework.LogInformation($"Vector64<SByte.GetElement({imm}): {nameof(RunReflectionScenario)} failed to throw ArgumentOutOfRangeException.");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
 
             succeeded = !expectedOutOfRangeException;
@@ -158,10 +158,10 @@ public void RunReflectionScenario(int imm = 0, bool expectedOutOfRangeException
 
             if (!succeeded)
             {
-                Succeeded = false;
-
                 TestLibrary.TestFramework.LogInformation($"Vector64<SByte.WithElement({imm}): {nameof(RunReflectionScenario)} failed to throw ArgumentOutOfRangeException.");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
 
@@ -196,27 +196,31 @@ private void ValidateWithResult(Vector64<SByte> result, SByte[] values, SByte in
 
         private void ValidateWithResult(SByte[] result, SByte[] values, SByte insertedValue, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             for (int i = 0; i < ElementCount; i++)
             {
                 if ((i != 0) && (result[i] != values[i]))
                 {
-                    Succeeded = false;
+                    succeeded = false;
                     break;
                 }
             }
 
             if (result[0] != insertedValue)
             {
-                Succeeded = false;
+                succeeded = false;
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"Vector64<SByte.WithElement(0): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"   value: ({string.Join(", ", values)})");
                 TestLibrary.TestFramework.LogInformation($"  insert: insertedValue");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/General/Vector64_1/GetAndWithElement.SByte.7.cs b/tests/src/JIT/HardwareIntrinsics/General/Vector64_1/GetAndWithElement.SByte.7.cs
index 74d787610b85..7d358afcfc01 100644
--- a/tests/src/JIT/HardwareIntrinsics/General/Vector64_1/GetAndWithElement.SByte.7.cs
+++ b/tests/src/JIT/HardwareIntrinsics/General/Vector64_1/GetAndWithElement.SByte.7.cs
@@ -74,10 +74,10 @@ public void RunBasicScenario(int imm = 7, bool expectedOutOfRangeException = fal
 
             if (!succeeded)
             {
-                Succeeded = false;
-
                 TestLibrary.TestFramework.LogInformation($"Vector64<SByte.GetElement({imm}): {nameof(RunBasicScenario)} failed to throw ArgumentOutOfRangeException.");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
 
             succeeded = !expectedOutOfRangeException;
@@ -96,10 +96,10 @@ public void RunBasicScenario(int imm = 7, bool expectedOutOfRangeException = fal
 
             if (!succeeded)
             {
-                Succeeded = false;
-
                 TestLibrary.TestFramework.LogInformation($"Vector64<SByte.WithElement({imm}): {nameof(RunBasicScenario)} failed to throw ArgumentOutOfRangeException.");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
 
@@ -133,10 +133,10 @@ public void RunReflectionScenario(int imm = 7, bool expectedOutOfRangeException
 
             if (!succeeded)
             {
-                Succeeded = false;
-
                 TestLibrary.TestFramework.LogInformation($"Vector64<SByte.GetElement({imm}): {nameof(RunReflectionScenario)} failed to throw ArgumentOutOfRangeException.");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
 
             succeeded = !expectedOutOfRangeException;
@@ -158,10 +158,10 @@ public void RunReflectionScenario(int imm = 7, bool expectedOutOfRangeException
 
             if (!succeeded)
             {
-                Succeeded = false;
-
                 TestLibrary.TestFramework.LogInformation($"Vector64<SByte.WithElement({imm}): {nameof(RunReflectionScenario)} failed to throw ArgumentOutOfRangeException.");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
 
@@ -196,27 +196,31 @@ private void ValidateWithResult(Vector64<SByte> result, SByte[] values, SByte in
 
         private void ValidateWithResult(SByte[] result, SByte[] values, SByte insertedValue, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             for (int i = 0; i < ElementCount; i++)
             {
                 if ((i != 7) && (result[i] != values[i]))
                 {
-                    Succeeded = false;
+                    succeeded = false;
                     break;
                 }
             }
 
             if (result[7] != insertedValue)
             {
-                Succeeded = false;
+                succeeded = false;
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"Vector64<SByte.WithElement(7): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"   value: ({string.Join(", ", values)})");
                 TestLibrary.TestFramework.LogInformation($"  insert: insertedValue");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/General/Vector64_1/GetAndWithElement.Single.0.cs b/tests/src/JIT/HardwareIntrinsics/General/Vector64_1/GetAndWithElement.Single.0.cs
index 4c300a1b9ad4..6e83521fe585 100644
--- a/tests/src/JIT/HardwareIntrinsics/General/Vector64_1/GetAndWithElement.Single.0.cs
+++ b/tests/src/JIT/HardwareIntrinsics/General/Vector64_1/GetAndWithElement.Single.0.cs
@@ -74,10 +74,10 @@ public void RunBasicScenario(int imm = 0, bool expectedOutOfRangeException = fal
 
             if (!succeeded)
             {
-                Succeeded = false;
-
                 TestLibrary.TestFramework.LogInformation($"Vector64<Single.GetElement({imm}): {nameof(RunBasicScenario)} failed to throw ArgumentOutOfRangeException.");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
 
             succeeded = !expectedOutOfRangeException;
@@ -96,10 +96,10 @@ public void RunBasicScenario(int imm = 0, bool expectedOutOfRangeException = fal
 
             if (!succeeded)
             {
-                Succeeded = false;
-
                 TestLibrary.TestFramework.LogInformation($"Vector64<Single.WithElement({imm}): {nameof(RunBasicScenario)} failed to throw ArgumentOutOfRangeException.");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
 
@@ -133,10 +133,10 @@ public void RunReflectionScenario(int imm = 0, bool expectedOutOfRangeException
 
             if (!succeeded)
             {
-                Succeeded = false;
-
                 TestLibrary.TestFramework.LogInformation($"Vector64<Single.GetElement({imm}): {nameof(RunReflectionScenario)} failed to throw ArgumentOutOfRangeException.");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
 
             succeeded = !expectedOutOfRangeException;
@@ -158,10 +158,10 @@ public void RunReflectionScenario(int imm = 0, bool expectedOutOfRangeException
 
             if (!succeeded)
             {
-                Succeeded = false;
-
                 TestLibrary.TestFramework.LogInformation($"Vector64<Single.WithElement({imm}): {nameof(RunReflectionScenario)} failed to throw ArgumentOutOfRangeException.");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
 
@@ -196,27 +196,31 @@ private void ValidateWithResult(Vector64<Single> result, Single[] values, Single
 
         private void ValidateWithResult(Single[] result, Single[] values, Single insertedValue, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             for (int i = 0; i < ElementCount; i++)
             {
                 if ((i != 0) && (result[i] != values[i]))
                 {
-                    Succeeded = false;
+                    succeeded = false;
                     break;
                 }
             }
 
             if (result[0] != insertedValue)
             {
-                Succeeded = false;
+                succeeded = false;
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"Vector64<Single.WithElement(0): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"   value: ({string.Join(", ", values)})");
                 TestLibrary.TestFramework.LogInformation($"  insert: insertedValue");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/General/Vector64_1/GetAndWithElement.Single.1.cs b/tests/src/JIT/HardwareIntrinsics/General/Vector64_1/GetAndWithElement.Single.1.cs
index 0bdf865b56e5..31f3685126c4 100644
--- a/tests/src/JIT/HardwareIntrinsics/General/Vector64_1/GetAndWithElement.Single.1.cs
+++ b/tests/src/JIT/HardwareIntrinsics/General/Vector64_1/GetAndWithElement.Single.1.cs
@@ -74,10 +74,10 @@ public void RunBasicScenario(int imm = 1, bool expectedOutOfRangeException = fal
 
             if (!succeeded)
             {
-                Succeeded = false;
-
                 TestLibrary.TestFramework.LogInformation($"Vector64<Single.GetElement({imm}): {nameof(RunBasicScenario)} failed to throw ArgumentOutOfRangeException.");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
 
             succeeded = !expectedOutOfRangeException;
@@ -96,10 +96,10 @@ public void RunBasicScenario(int imm = 1, bool expectedOutOfRangeException = fal
 
             if (!succeeded)
             {
-                Succeeded = false;
-
                 TestLibrary.TestFramework.LogInformation($"Vector64<Single.WithElement({imm}): {nameof(RunBasicScenario)} failed to throw ArgumentOutOfRangeException.");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
 
@@ -133,10 +133,10 @@ public void RunReflectionScenario(int imm = 1, bool expectedOutOfRangeException
 
             if (!succeeded)
             {
-                Succeeded = false;
-
                 TestLibrary.TestFramework.LogInformation($"Vector64<Single.GetElement({imm}): {nameof(RunReflectionScenario)} failed to throw ArgumentOutOfRangeException.");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
 
             succeeded = !expectedOutOfRangeException;
@@ -158,10 +158,10 @@ public void RunReflectionScenario(int imm = 1, bool expectedOutOfRangeException
 
             if (!succeeded)
             {
-                Succeeded = false;
-
                 TestLibrary.TestFramework.LogInformation($"Vector64<Single.WithElement({imm}): {nameof(RunReflectionScenario)} failed to throw ArgumentOutOfRangeException.");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
 
@@ -196,27 +196,31 @@ private void ValidateWithResult(Vector64<Single> result, Single[] values, Single
 
         private void ValidateWithResult(Single[] result, Single[] values, Single insertedValue, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             for (int i = 0; i < ElementCount; i++)
             {
                 if ((i != 1) && (result[i] != values[i]))
                 {
-                    Succeeded = false;
+                    succeeded = false;
                     break;
                 }
             }
 
             if (result[1] != insertedValue)
             {
-                Succeeded = false;
+                succeeded = false;
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"Vector64<Single.WithElement(1): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"   value: ({string.Join(", ", values)})");
                 TestLibrary.TestFramework.LogInformation($"  insert: insertedValue");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/General/Vector64_1/GetAndWithElement.UInt16.0.cs b/tests/src/JIT/HardwareIntrinsics/General/Vector64_1/GetAndWithElement.UInt16.0.cs
index 12eaf9b7eeee..57757c1f28b6 100644
--- a/tests/src/JIT/HardwareIntrinsics/General/Vector64_1/GetAndWithElement.UInt16.0.cs
+++ b/tests/src/JIT/HardwareIntrinsics/General/Vector64_1/GetAndWithElement.UInt16.0.cs
@@ -74,10 +74,10 @@ public void RunBasicScenario(int imm = 0, bool expectedOutOfRangeException = fal
 
             if (!succeeded)
             {
-                Succeeded = false;
-
                 TestLibrary.TestFramework.LogInformation($"Vector64<UInt16.GetElement({imm}): {nameof(RunBasicScenario)} failed to throw ArgumentOutOfRangeException.");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
 
             succeeded = !expectedOutOfRangeException;
@@ -96,10 +96,10 @@ public void RunBasicScenario(int imm = 0, bool expectedOutOfRangeException = fal
 
             if (!succeeded)
             {
-                Succeeded = false;
-
                 TestLibrary.TestFramework.LogInformation($"Vector64<UInt16.WithElement({imm}): {nameof(RunBasicScenario)} failed to throw ArgumentOutOfRangeException.");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
 
@@ -133,10 +133,10 @@ public void RunReflectionScenario(int imm = 0, bool expectedOutOfRangeException
 
             if (!succeeded)
             {
-                Succeeded = false;
-
                 TestLibrary.TestFramework.LogInformation($"Vector64<UInt16.GetElement({imm}): {nameof(RunReflectionScenario)} failed to throw ArgumentOutOfRangeException.");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
 
             succeeded = !expectedOutOfRangeException;
@@ -158,10 +158,10 @@ public void RunReflectionScenario(int imm = 0, bool expectedOutOfRangeException
 
             if (!succeeded)
             {
-                Succeeded = false;
-
                 TestLibrary.TestFramework.LogInformation($"Vector64<UInt16.WithElement({imm}): {nameof(RunReflectionScenario)} failed to throw ArgumentOutOfRangeException.");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
 
@@ -196,27 +196,31 @@ private void ValidateWithResult(Vector64<UInt16> result, UInt16[] values, UInt16
 
         private void ValidateWithResult(UInt16[] result, UInt16[] values, UInt16 insertedValue, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             for (int i = 0; i < ElementCount; i++)
             {
                 if ((i != 0) && (result[i] != values[i]))
                 {
-                    Succeeded = false;
+                    succeeded = false;
                     break;
                 }
             }
 
             if (result[0] != insertedValue)
             {
-                Succeeded = false;
+                succeeded = false;
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"Vector64<UInt16.WithElement(0): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"   value: ({string.Join(", ", values)})");
                 TestLibrary.TestFramework.LogInformation($"  insert: insertedValue");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/General/Vector64_1/GetAndWithElement.UInt16.3.cs b/tests/src/JIT/HardwareIntrinsics/General/Vector64_1/GetAndWithElement.UInt16.3.cs
index c6365aaa9b4b..ff3920e0b744 100644
--- a/tests/src/JIT/HardwareIntrinsics/General/Vector64_1/GetAndWithElement.UInt16.3.cs
+++ b/tests/src/JIT/HardwareIntrinsics/General/Vector64_1/GetAndWithElement.UInt16.3.cs
@@ -74,10 +74,10 @@ public void RunBasicScenario(int imm = 3, bool expectedOutOfRangeException = fal
 
             if (!succeeded)
             {
-                Succeeded = false;
-
                 TestLibrary.TestFramework.LogInformation($"Vector64<UInt16.GetElement({imm}): {nameof(RunBasicScenario)} failed to throw ArgumentOutOfRangeException.");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
 
             succeeded = !expectedOutOfRangeException;
@@ -96,10 +96,10 @@ public void RunBasicScenario(int imm = 3, bool expectedOutOfRangeException = fal
 
             if (!succeeded)
             {
-                Succeeded = false;
-
                 TestLibrary.TestFramework.LogInformation($"Vector64<UInt16.WithElement({imm}): {nameof(RunBasicScenario)} failed to throw ArgumentOutOfRangeException.");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
 
@@ -133,10 +133,10 @@ public void RunReflectionScenario(int imm = 3, bool expectedOutOfRangeException
 
             if (!succeeded)
             {
-                Succeeded = false;
-
                 TestLibrary.TestFramework.LogInformation($"Vector64<UInt16.GetElement({imm}): {nameof(RunReflectionScenario)} failed to throw ArgumentOutOfRangeException.");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
 
             succeeded = !expectedOutOfRangeException;
@@ -158,10 +158,10 @@ public void RunReflectionScenario(int imm = 3, bool expectedOutOfRangeException
 
             if (!succeeded)
             {
-                Succeeded = false;
-
                 TestLibrary.TestFramework.LogInformation($"Vector64<UInt16.WithElement({imm}): {nameof(RunReflectionScenario)} failed to throw ArgumentOutOfRangeException.");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
 
@@ -196,27 +196,31 @@ private void ValidateWithResult(Vector64<UInt16> result, UInt16[] values, UInt16
 
         private void ValidateWithResult(UInt16[] result, UInt16[] values, UInt16 insertedValue, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             for (int i = 0; i < ElementCount; i++)
             {
                 if ((i != 3) && (result[i] != values[i]))
                 {
-                    Succeeded = false;
+                    succeeded = false;
                     break;
                 }
             }
 
             if (result[3] != insertedValue)
             {
-                Succeeded = false;
+                succeeded = false;
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"Vector64<UInt16.WithElement(3): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"   value: ({string.Join(", ", values)})");
                 TestLibrary.TestFramework.LogInformation($"  insert: insertedValue");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/General/Vector64_1/GetAndWithElement.UInt32.0.cs b/tests/src/JIT/HardwareIntrinsics/General/Vector64_1/GetAndWithElement.UInt32.0.cs
index 1c608d795efe..fa5f0fa5e1e0 100644
--- a/tests/src/JIT/HardwareIntrinsics/General/Vector64_1/GetAndWithElement.UInt32.0.cs
+++ b/tests/src/JIT/HardwareIntrinsics/General/Vector64_1/GetAndWithElement.UInt32.0.cs
@@ -74,10 +74,10 @@ public void RunBasicScenario(int imm = 0, bool expectedOutOfRangeException = fal
 
             if (!succeeded)
             {
-                Succeeded = false;
-
                 TestLibrary.TestFramework.LogInformation($"Vector64<UInt32.GetElement({imm}): {nameof(RunBasicScenario)} failed to throw ArgumentOutOfRangeException.");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
 
             succeeded = !expectedOutOfRangeException;
@@ -96,10 +96,10 @@ public void RunBasicScenario(int imm = 0, bool expectedOutOfRangeException = fal
 
             if (!succeeded)
             {
-                Succeeded = false;
-
                 TestLibrary.TestFramework.LogInformation($"Vector64<UInt32.WithElement({imm}): {nameof(RunBasicScenario)} failed to throw ArgumentOutOfRangeException.");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
 
@@ -133,10 +133,10 @@ public void RunReflectionScenario(int imm = 0, bool expectedOutOfRangeException
 
             if (!succeeded)
             {
-                Succeeded = false;
-
                 TestLibrary.TestFramework.LogInformation($"Vector64<UInt32.GetElement({imm}): {nameof(RunReflectionScenario)} failed to throw ArgumentOutOfRangeException.");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
 
             succeeded = !expectedOutOfRangeException;
@@ -158,10 +158,10 @@ public void RunReflectionScenario(int imm = 0, bool expectedOutOfRangeException
 
             if (!succeeded)
             {
-                Succeeded = false;
-
                 TestLibrary.TestFramework.LogInformation($"Vector64<UInt32.WithElement({imm}): {nameof(RunReflectionScenario)} failed to throw ArgumentOutOfRangeException.");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
 
@@ -196,27 +196,31 @@ private void ValidateWithResult(Vector64<UInt32> result, UInt32[] values, UInt32
 
         private void ValidateWithResult(UInt32[] result, UInt32[] values, UInt32 insertedValue, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             for (int i = 0; i < ElementCount; i++)
             {
                 if ((i != 0) && (result[i] != values[i]))
                 {
-                    Succeeded = false;
+                    succeeded = false;
                     break;
                 }
             }
 
             if (result[0] != insertedValue)
             {
-                Succeeded = false;
+                succeeded = false;
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"Vector64<UInt32.WithElement(0): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"   value: ({string.Join(", ", values)})");
                 TestLibrary.TestFramework.LogInformation($"  insert: insertedValue");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/General/Vector64_1/GetAndWithElement.UInt32.1.cs b/tests/src/JIT/HardwareIntrinsics/General/Vector64_1/GetAndWithElement.UInt32.1.cs
index 001fb506fbb8..847626e62e27 100644
--- a/tests/src/JIT/HardwareIntrinsics/General/Vector64_1/GetAndWithElement.UInt32.1.cs
+++ b/tests/src/JIT/HardwareIntrinsics/General/Vector64_1/GetAndWithElement.UInt32.1.cs
@@ -74,10 +74,10 @@ public void RunBasicScenario(int imm = 1, bool expectedOutOfRangeException = fal
 
             if (!succeeded)
             {
-                Succeeded = false;
-
                 TestLibrary.TestFramework.LogInformation($"Vector64<UInt32.GetElement({imm}): {nameof(RunBasicScenario)} failed to throw ArgumentOutOfRangeException.");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
 
             succeeded = !expectedOutOfRangeException;
@@ -96,10 +96,10 @@ public void RunBasicScenario(int imm = 1, bool expectedOutOfRangeException = fal
 
             if (!succeeded)
             {
-                Succeeded = false;
-
                 TestLibrary.TestFramework.LogInformation($"Vector64<UInt32.WithElement({imm}): {nameof(RunBasicScenario)} failed to throw ArgumentOutOfRangeException.");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
 
@@ -133,10 +133,10 @@ public void RunReflectionScenario(int imm = 1, bool expectedOutOfRangeException
 
             if (!succeeded)
             {
-                Succeeded = false;
-
                 TestLibrary.TestFramework.LogInformation($"Vector64<UInt32.GetElement({imm}): {nameof(RunReflectionScenario)} failed to throw ArgumentOutOfRangeException.");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
 
             succeeded = !expectedOutOfRangeException;
@@ -158,10 +158,10 @@ public void RunReflectionScenario(int imm = 1, bool expectedOutOfRangeException
 
             if (!succeeded)
             {
-                Succeeded = false;
-
                 TestLibrary.TestFramework.LogInformation($"Vector64<UInt32.WithElement({imm}): {nameof(RunReflectionScenario)} failed to throw ArgumentOutOfRangeException.");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
 
@@ -196,27 +196,31 @@ private void ValidateWithResult(Vector64<UInt32> result, UInt32[] values, UInt32
 
         private void ValidateWithResult(UInt32[] result, UInt32[] values, UInt32 insertedValue, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             for (int i = 0; i < ElementCount; i++)
             {
                 if ((i != 1) && (result[i] != values[i]))
                 {
-                    Succeeded = false;
+                    succeeded = false;
                     break;
                 }
             }
 
             if (result[1] != insertedValue)
             {
-                Succeeded = false;
+                succeeded = false;
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"Vector64<UInt32.WithElement(1): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"   value: ({string.Join(", ", values)})");
                 TestLibrary.TestFramework.LogInformation($"  insert: insertedValue");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/General/Vector64_1/GetAndWithElement.UInt64.0.cs b/tests/src/JIT/HardwareIntrinsics/General/Vector64_1/GetAndWithElement.UInt64.0.cs
index 7630dbeb92f9..86f3d0a55caa 100644
--- a/tests/src/JIT/HardwareIntrinsics/General/Vector64_1/GetAndWithElement.UInt64.0.cs
+++ b/tests/src/JIT/HardwareIntrinsics/General/Vector64_1/GetAndWithElement.UInt64.0.cs
@@ -74,10 +74,10 @@ public void RunBasicScenario(int imm = 0, bool expectedOutOfRangeException = fal
 
             if (!succeeded)
             {
-                Succeeded = false;
-
                 TestLibrary.TestFramework.LogInformation($"Vector64<UInt64.GetElement({imm}): {nameof(RunBasicScenario)} failed to throw ArgumentOutOfRangeException.");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
 
             succeeded = !expectedOutOfRangeException;
@@ -96,10 +96,10 @@ public void RunBasicScenario(int imm = 0, bool expectedOutOfRangeException = fal
 
             if (!succeeded)
             {
-                Succeeded = false;
-
                 TestLibrary.TestFramework.LogInformation($"Vector64<UInt64.WithElement({imm}): {nameof(RunBasicScenario)} failed to throw ArgumentOutOfRangeException.");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
 
@@ -133,10 +133,10 @@ public void RunReflectionScenario(int imm = 0, bool expectedOutOfRangeException
 
             if (!succeeded)
             {
-                Succeeded = false;
-
                 TestLibrary.TestFramework.LogInformation($"Vector64<UInt64.GetElement({imm}): {nameof(RunReflectionScenario)} failed to throw ArgumentOutOfRangeException.");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
 
             succeeded = !expectedOutOfRangeException;
@@ -158,10 +158,10 @@ public void RunReflectionScenario(int imm = 0, bool expectedOutOfRangeException
 
             if (!succeeded)
             {
-                Succeeded = false;
-
                 TestLibrary.TestFramework.LogInformation($"Vector64<UInt64.WithElement({imm}): {nameof(RunReflectionScenario)} failed to throw ArgumentOutOfRangeException.");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
 
@@ -196,27 +196,31 @@ private void ValidateWithResult(Vector64<UInt64> result, UInt64[] values, UInt64
 
         private void ValidateWithResult(UInt64[] result, UInt64[] values, UInt64 insertedValue, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             for (int i = 0; i < ElementCount; i++)
             {
                 if ((i != 0) && (result[i] != values[i]))
                 {
-                    Succeeded = false;
+                    succeeded = false;
                     break;
                 }
             }
 
             if (result[0] != insertedValue)
             {
-                Succeeded = false;
+                succeeded = false;
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"Vector64<UInt64.WithElement(0): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"   value: ({string.Join(", ", values)})");
                 TestLibrary.TestFramework.LogInformation($"  insert: insertedValue");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/General/Vector64_1/ToScalar.Byte.cs b/tests/src/JIT/HardwareIntrinsics/General/Vector64_1/ToScalar.Byte.cs
index 8668f0fe5904..dca7263b7b89 100644
--- a/tests/src/JIT/HardwareIntrinsics/General/Vector64_1/ToScalar.Byte.cs
+++ b/tests/src/JIT/HardwareIntrinsics/General/Vector64_1/ToScalar.Byte.cs
@@ -84,12 +84,12 @@ private void ValidateResult(Byte result, Byte[] values, [CallerMemberName] strin
         {
             if (result != values[0])
             {
-                Succeeded = false;
-
                 TestLibrary.TestFramework.LogInformation($"Vector64<Byte>.ToScalar(): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"  values: ({string.Join(", ", values)})");
                 TestLibrary.TestFramework.LogInformation($"  result: {result}");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/General/Vector64_1/ToScalar.Double.cs b/tests/src/JIT/HardwareIntrinsics/General/Vector64_1/ToScalar.Double.cs
index 2a25add5b547..22b6260eabe8 100644
--- a/tests/src/JIT/HardwareIntrinsics/General/Vector64_1/ToScalar.Double.cs
+++ b/tests/src/JIT/HardwareIntrinsics/General/Vector64_1/ToScalar.Double.cs
@@ -84,12 +84,12 @@ private void ValidateResult(Double result, Double[] values, [CallerMemberName] s
         {
             if (result != values[0])
             {
-                Succeeded = false;
-
                 TestLibrary.TestFramework.LogInformation($"Vector64<Double>.ToScalar(): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"  values: ({string.Join(", ", values)})");
                 TestLibrary.TestFramework.LogInformation($"  result: {result}");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/General/Vector64_1/ToScalar.Int16.cs b/tests/src/JIT/HardwareIntrinsics/General/Vector64_1/ToScalar.Int16.cs
index a24ddf7da22f..e37c2d57aa34 100644
--- a/tests/src/JIT/HardwareIntrinsics/General/Vector64_1/ToScalar.Int16.cs
+++ b/tests/src/JIT/HardwareIntrinsics/General/Vector64_1/ToScalar.Int16.cs
@@ -84,12 +84,12 @@ private void ValidateResult(Int16 result, Int16[] values, [CallerMemberName] str
         {
             if (result != values[0])
             {
-                Succeeded = false;
-
                 TestLibrary.TestFramework.LogInformation($"Vector64<Int16>.ToScalar(): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"  values: ({string.Join(", ", values)})");
                 TestLibrary.TestFramework.LogInformation($"  result: {result}");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/General/Vector64_1/ToScalar.Int32.cs b/tests/src/JIT/HardwareIntrinsics/General/Vector64_1/ToScalar.Int32.cs
index 7542ecc095dc..aee38d0efe77 100644
--- a/tests/src/JIT/HardwareIntrinsics/General/Vector64_1/ToScalar.Int32.cs
+++ b/tests/src/JIT/HardwareIntrinsics/General/Vector64_1/ToScalar.Int32.cs
@@ -84,12 +84,12 @@ private void ValidateResult(Int32 result, Int32[] values, [CallerMemberName] str
         {
             if (result != values[0])
             {
-                Succeeded = false;
-
                 TestLibrary.TestFramework.LogInformation($"Vector64<Int32>.ToScalar(): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"  values: ({string.Join(", ", values)})");
                 TestLibrary.TestFramework.LogInformation($"  result: {result}");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/General/Vector64_1/ToScalar.Int64.cs b/tests/src/JIT/HardwareIntrinsics/General/Vector64_1/ToScalar.Int64.cs
index e3913146ee50..582259438d98 100644
--- a/tests/src/JIT/HardwareIntrinsics/General/Vector64_1/ToScalar.Int64.cs
+++ b/tests/src/JIT/HardwareIntrinsics/General/Vector64_1/ToScalar.Int64.cs
@@ -84,12 +84,12 @@ private void ValidateResult(Int64 result, Int64[] values, [CallerMemberName] str
         {
             if (result != values[0])
             {
-                Succeeded = false;
-
                 TestLibrary.TestFramework.LogInformation($"Vector64<Int64>.ToScalar(): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"  values: ({string.Join(", ", values)})");
                 TestLibrary.TestFramework.LogInformation($"  result: {result}");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/General/Vector64_1/ToScalar.SByte.cs b/tests/src/JIT/HardwareIntrinsics/General/Vector64_1/ToScalar.SByte.cs
index abcf2fbb1ffd..f7e3a29d37b6 100644
--- a/tests/src/JIT/HardwareIntrinsics/General/Vector64_1/ToScalar.SByte.cs
+++ b/tests/src/JIT/HardwareIntrinsics/General/Vector64_1/ToScalar.SByte.cs
@@ -84,12 +84,12 @@ private void ValidateResult(SByte result, SByte[] values, [CallerMemberName] str
         {
             if (result != values[0])
             {
-                Succeeded = false;
-
                 TestLibrary.TestFramework.LogInformation($"Vector64<SByte>.ToScalar(): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"  values: ({string.Join(", ", values)})");
                 TestLibrary.TestFramework.LogInformation($"  result: {result}");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/General/Vector64_1/ToScalar.Single.cs b/tests/src/JIT/HardwareIntrinsics/General/Vector64_1/ToScalar.Single.cs
index 56edd62d09e6..f3a85fcc360f 100644
--- a/tests/src/JIT/HardwareIntrinsics/General/Vector64_1/ToScalar.Single.cs
+++ b/tests/src/JIT/HardwareIntrinsics/General/Vector64_1/ToScalar.Single.cs
@@ -84,12 +84,12 @@ private void ValidateResult(Single result, Single[] values, [CallerMemberName] s
         {
             if (result != values[0])
             {
-                Succeeded = false;
-
                 TestLibrary.TestFramework.LogInformation($"Vector64<Single>.ToScalar(): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"  values: ({string.Join(", ", values)})");
                 TestLibrary.TestFramework.LogInformation($"  result: {result}");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/General/Vector64_1/ToScalar.UInt16.cs b/tests/src/JIT/HardwareIntrinsics/General/Vector64_1/ToScalar.UInt16.cs
index 3068b5f82c49..f5030074eefd 100644
--- a/tests/src/JIT/HardwareIntrinsics/General/Vector64_1/ToScalar.UInt16.cs
+++ b/tests/src/JIT/HardwareIntrinsics/General/Vector64_1/ToScalar.UInt16.cs
@@ -84,12 +84,12 @@ private void ValidateResult(UInt16 result, UInt16[] values, [CallerMemberName] s
         {
             if (result != values[0])
             {
-                Succeeded = false;
-
                 TestLibrary.TestFramework.LogInformation($"Vector64<UInt16>.ToScalar(): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"  values: ({string.Join(", ", values)})");
                 TestLibrary.TestFramework.LogInformation($"  result: {result}");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/General/Vector64_1/ToScalar.UInt32.cs b/tests/src/JIT/HardwareIntrinsics/General/Vector64_1/ToScalar.UInt32.cs
index 7f61f92e3faf..79590bf48bf5 100644
--- a/tests/src/JIT/HardwareIntrinsics/General/Vector64_1/ToScalar.UInt32.cs
+++ b/tests/src/JIT/HardwareIntrinsics/General/Vector64_1/ToScalar.UInt32.cs
@@ -84,12 +84,12 @@ private void ValidateResult(UInt32 result, UInt32[] values, [CallerMemberName] s
         {
             if (result != values[0])
             {
-                Succeeded = false;
-
                 TestLibrary.TestFramework.LogInformation($"Vector64<UInt32>.ToScalar(): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"  values: ({string.Join(", ", values)})");
                 TestLibrary.TestFramework.LogInformation($"  result: {result}");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/General/Vector64_1/ToScalar.UInt64.cs b/tests/src/JIT/HardwareIntrinsics/General/Vector64_1/ToScalar.UInt64.cs
index cf63e076ffb8..4abab9863576 100644
--- a/tests/src/JIT/HardwareIntrinsics/General/Vector64_1/ToScalar.UInt64.cs
+++ b/tests/src/JIT/HardwareIntrinsics/General/Vector64_1/ToScalar.UInt64.cs
@@ -84,12 +84,12 @@ private void ValidateResult(UInt64 result, UInt64[] values, [CallerMemberName] s
         {
             if (result != values[0])
             {
-                Succeeded = false;
-
                 TestLibrary.TestFramework.LogInformation($"Vector64<UInt64>.ToScalar(): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"  values: ({string.Join(", ", values)})");
                 TestLibrary.TestFramework.LogInformation($"  result: {result}");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/General/Vector64_1/ToVector128.Byte.cs b/tests/src/JIT/HardwareIntrinsics/General/Vector64_1/ToVector128.Byte.cs
index d9194a19c819..377f77f6de10 100644
--- a/tests/src/JIT/HardwareIntrinsics/General/Vector64_1/ToVector128.Byte.cs
+++ b/tests/src/JIT/HardwareIntrinsics/General/Vector64_1/ToVector128.Byte.cs
@@ -97,11 +97,13 @@ private void ValidateResult(Vector128<Byte> result, Byte[] values, bool isUnsafe
 
         private void ValidateResult(Byte[] result, Byte[] values, bool isUnsafe, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             for (int i = 0; i < ElementCount; i++)
             {
                 if (result[i] != values[i])
                 {
-                    Succeeded = false;
+                    succeeded = false;
                     break;
                 }
             }
@@ -112,18 +114,20 @@ private void ValidateResult(Byte[] result, Byte[] values, bool isUnsafe, [Caller
                 {
                     if (result[i] != 0)
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"Vector64<Byte>.ToVector128{(isUnsafe ? "Unsafe" : "")}(): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"   value: ({string.Join(", ", values)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/General/Vector64_1/ToVector128.Double.cs b/tests/src/JIT/HardwareIntrinsics/General/Vector64_1/ToVector128.Double.cs
index e8b3dca6cbf4..f1f8a6aa10d2 100644
--- a/tests/src/JIT/HardwareIntrinsics/General/Vector64_1/ToVector128.Double.cs
+++ b/tests/src/JIT/HardwareIntrinsics/General/Vector64_1/ToVector128.Double.cs
@@ -97,11 +97,13 @@ private void ValidateResult(Vector128<Double> result, Double[] values, bool isUn
 
         private void ValidateResult(Double[] result, Double[] values, bool isUnsafe, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             for (int i = 0; i < ElementCount; i++)
             {
                 if (result[i] != values[i])
                 {
-                    Succeeded = false;
+                    succeeded = false;
                     break;
                 }
             }
@@ -112,18 +114,20 @@ private void ValidateResult(Double[] result, Double[] values, bool isUnsafe, [Ca
                 {
                     if (result[i] != 0)
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"Vector64<Double>.ToVector128{(isUnsafe ? "Unsafe" : "")}(): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"   value: ({string.Join(", ", values)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/General/Vector64_1/ToVector128.Int16.cs b/tests/src/JIT/HardwareIntrinsics/General/Vector64_1/ToVector128.Int16.cs
index 20aa99854f81..69d2e753f782 100644
--- a/tests/src/JIT/HardwareIntrinsics/General/Vector64_1/ToVector128.Int16.cs
+++ b/tests/src/JIT/HardwareIntrinsics/General/Vector64_1/ToVector128.Int16.cs
@@ -97,11 +97,13 @@ private void ValidateResult(Vector128<Int16> result, Int16[] values, bool isUnsa
 
         private void ValidateResult(Int16[] result, Int16[] values, bool isUnsafe, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             for (int i = 0; i < ElementCount; i++)
             {
                 if (result[i] != values[i])
                 {
-                    Succeeded = false;
+                    succeeded = false;
                     break;
                 }
             }
@@ -112,18 +114,20 @@ private void ValidateResult(Int16[] result, Int16[] values, bool isUnsafe, [Call
                 {
                     if (result[i] != 0)
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"Vector64<Int16>.ToVector128{(isUnsafe ? "Unsafe" : "")}(): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"   value: ({string.Join(", ", values)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/General/Vector64_1/ToVector128.Int32.cs b/tests/src/JIT/HardwareIntrinsics/General/Vector64_1/ToVector128.Int32.cs
index 0e1da7a72043..6ffe6dfeb964 100644
--- a/tests/src/JIT/HardwareIntrinsics/General/Vector64_1/ToVector128.Int32.cs
+++ b/tests/src/JIT/HardwareIntrinsics/General/Vector64_1/ToVector128.Int32.cs
@@ -97,11 +97,13 @@ private void ValidateResult(Vector128<Int32> result, Int32[] values, bool isUnsa
 
         private void ValidateResult(Int32[] result, Int32[] values, bool isUnsafe, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             for (int i = 0; i < ElementCount; i++)
             {
                 if (result[i] != values[i])
                 {
-                    Succeeded = false;
+                    succeeded = false;
                     break;
                 }
             }
@@ -112,18 +114,20 @@ private void ValidateResult(Int32[] result, Int32[] values, bool isUnsafe, [Call
                 {
                     if (result[i] != 0)
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"Vector64<Int32>.ToVector128{(isUnsafe ? "Unsafe" : "")}(): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"   value: ({string.Join(", ", values)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/General/Vector64_1/ToVector128.Int64.cs b/tests/src/JIT/HardwareIntrinsics/General/Vector64_1/ToVector128.Int64.cs
index 5a4517d30232..94b0295cb238 100644
--- a/tests/src/JIT/HardwareIntrinsics/General/Vector64_1/ToVector128.Int64.cs
+++ b/tests/src/JIT/HardwareIntrinsics/General/Vector64_1/ToVector128.Int64.cs
@@ -97,11 +97,13 @@ private void ValidateResult(Vector128<Int64> result, Int64[] values, bool isUnsa
 
         private void ValidateResult(Int64[] result, Int64[] values, bool isUnsafe, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             for (int i = 0; i < ElementCount; i++)
             {
                 if (result[i] != values[i])
                 {
-                    Succeeded = false;
+                    succeeded = false;
                     break;
                 }
             }
@@ -112,18 +114,20 @@ private void ValidateResult(Int64[] result, Int64[] values, bool isUnsafe, [Call
                 {
                     if (result[i] != 0)
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"Vector64<Int64>.ToVector128{(isUnsafe ? "Unsafe" : "")}(): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"   value: ({string.Join(", ", values)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/General/Vector64_1/ToVector128.SByte.cs b/tests/src/JIT/HardwareIntrinsics/General/Vector64_1/ToVector128.SByte.cs
index 8818a2cf075d..848ebc0f2a69 100644
--- a/tests/src/JIT/HardwareIntrinsics/General/Vector64_1/ToVector128.SByte.cs
+++ b/tests/src/JIT/HardwareIntrinsics/General/Vector64_1/ToVector128.SByte.cs
@@ -97,11 +97,13 @@ private void ValidateResult(Vector128<SByte> result, SByte[] values, bool isUnsa
 
         private void ValidateResult(SByte[] result, SByte[] values, bool isUnsafe, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             for (int i = 0; i < ElementCount; i++)
             {
                 if (result[i] != values[i])
                 {
-                    Succeeded = false;
+                    succeeded = false;
                     break;
                 }
             }
@@ -112,18 +114,20 @@ private void ValidateResult(SByte[] result, SByte[] values, bool isUnsafe, [Call
                 {
                     if (result[i] != 0)
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"Vector64<SByte>.ToVector128{(isUnsafe ? "Unsafe" : "")}(): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"   value: ({string.Join(", ", values)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/General/Vector64_1/ToVector128.Single.cs b/tests/src/JIT/HardwareIntrinsics/General/Vector64_1/ToVector128.Single.cs
index e4098c54926b..d0244dde951d 100644
--- a/tests/src/JIT/HardwareIntrinsics/General/Vector64_1/ToVector128.Single.cs
+++ b/tests/src/JIT/HardwareIntrinsics/General/Vector64_1/ToVector128.Single.cs
@@ -97,11 +97,13 @@ private void ValidateResult(Vector128<Single> result, Single[] values, bool isUn
 
         private void ValidateResult(Single[] result, Single[] values, bool isUnsafe, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             for (int i = 0; i < ElementCount; i++)
             {
                 if (result[i] != values[i])
                 {
-                    Succeeded = false;
+                    succeeded = false;
                     break;
                 }
             }
@@ -112,18 +114,20 @@ private void ValidateResult(Single[] result, Single[] values, bool isUnsafe, [Ca
                 {
                     if (result[i] != 0)
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"Vector64<Single>.ToVector128{(isUnsafe ? "Unsafe" : "")}(): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"   value: ({string.Join(", ", values)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/General/Vector64_1/ToVector128.UInt16.cs b/tests/src/JIT/HardwareIntrinsics/General/Vector64_1/ToVector128.UInt16.cs
index 9e499cfa2ef0..4030c0b81472 100644
--- a/tests/src/JIT/HardwareIntrinsics/General/Vector64_1/ToVector128.UInt16.cs
+++ b/tests/src/JIT/HardwareIntrinsics/General/Vector64_1/ToVector128.UInt16.cs
@@ -97,11 +97,13 @@ private void ValidateResult(Vector128<UInt16> result, UInt16[] values, bool isUn
 
         private void ValidateResult(UInt16[] result, UInt16[] values, bool isUnsafe, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             for (int i = 0; i < ElementCount; i++)
             {
                 if (result[i] != values[i])
                 {
-                    Succeeded = false;
+                    succeeded = false;
                     break;
                 }
             }
@@ -112,18 +114,20 @@ private void ValidateResult(UInt16[] result, UInt16[] values, bool isUnsafe, [Ca
                 {
                     if (result[i] != 0)
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"Vector64<UInt16>.ToVector128{(isUnsafe ? "Unsafe" : "")}(): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"   value: ({string.Join(", ", values)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/General/Vector64_1/ToVector128.UInt32.cs b/tests/src/JIT/HardwareIntrinsics/General/Vector64_1/ToVector128.UInt32.cs
index 5c6cd586fd56..4b18abfe9119 100644
--- a/tests/src/JIT/HardwareIntrinsics/General/Vector64_1/ToVector128.UInt32.cs
+++ b/tests/src/JIT/HardwareIntrinsics/General/Vector64_1/ToVector128.UInt32.cs
@@ -97,11 +97,13 @@ private void ValidateResult(Vector128<UInt32> result, UInt32[] values, bool isUn
 
         private void ValidateResult(UInt32[] result, UInt32[] values, bool isUnsafe, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             for (int i = 0; i < ElementCount; i++)
             {
                 if (result[i] != values[i])
                 {
-                    Succeeded = false;
+                    succeeded = false;
                     break;
                 }
             }
@@ -112,18 +114,20 @@ private void ValidateResult(UInt32[] result, UInt32[] values, bool isUnsafe, [Ca
                 {
                     if (result[i] != 0)
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"Vector64<UInt32>.ToVector128{(isUnsafe ? "Unsafe" : "")}(): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"   value: ({string.Join(", ", values)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/General/Vector64_1/ToVector128.UInt64.cs b/tests/src/JIT/HardwareIntrinsics/General/Vector64_1/ToVector128.UInt64.cs
index 11856ae996fa..7693cb9bee51 100644
--- a/tests/src/JIT/HardwareIntrinsics/General/Vector64_1/ToVector128.UInt64.cs
+++ b/tests/src/JIT/HardwareIntrinsics/General/Vector64_1/ToVector128.UInt64.cs
@@ -97,11 +97,13 @@ private void ValidateResult(Vector128<UInt64> result, UInt64[] values, bool isUn
 
         private void ValidateResult(UInt64[] result, UInt64[] values, bool isUnsafe, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             for (int i = 0; i < ElementCount; i++)
             {
                 if (result[i] != values[i])
                 {
-                    Succeeded = false;
+                    succeeded = false;
                     break;
                 }
             }
@@ -112,18 +114,20 @@ private void ValidateResult(UInt64[] result, UInt64[] values, bool isUnsafe, [Ca
                 {
                     if (result[i] != 0)
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"Vector64<UInt64>.ToVector128{(isUnsafe ? "Unsafe" : "")}(): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"   value: ({string.Join(", ", values)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/General/Vector64_1/Zero.Byte.cs b/tests/src/JIT/HardwareIntrinsics/General/Vector64_1/Zero.Byte.cs
index 4cb741a695d3..eda5abb31c8b 100644
--- a/tests/src/JIT/HardwareIntrinsics/General/Vector64_1/Zero.Byte.cs
+++ b/tests/src/JIT/HardwareIntrinsics/General/Vector64_1/Zero.Byte.cs
@@ -73,20 +73,24 @@ private void ValidateResult(Vector64<Byte> result, [CallerMemberName] string met
 
         private void ValidateResult(Byte[] resultElements, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+        
             for (var i = 0; i < ElementCount; i++)
             {
                 if (resultElements[i] != 0)
                 {
-                    Succeeded = false;
+                    succeeded = false;
                     break;
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"Vector64.Zero(Byte): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", resultElements)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/General/Vector64_1/Zero.Double.cs b/tests/src/JIT/HardwareIntrinsics/General/Vector64_1/Zero.Double.cs
index 7d69f5e4fb74..348078393b04 100644
--- a/tests/src/JIT/HardwareIntrinsics/General/Vector64_1/Zero.Double.cs
+++ b/tests/src/JIT/HardwareIntrinsics/General/Vector64_1/Zero.Double.cs
@@ -73,20 +73,24 @@ private void ValidateResult(Vector64<Double> result, [CallerMemberName] string m
 
         private void ValidateResult(Double[] resultElements, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+        
             for (var i = 0; i < ElementCount; i++)
             {
                 if (resultElements[i] != 0)
                 {
-                    Succeeded = false;
+                    succeeded = false;
                     break;
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"Vector64.Zero(Double): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", resultElements)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/General/Vector64_1/Zero.Int16.cs b/tests/src/JIT/HardwareIntrinsics/General/Vector64_1/Zero.Int16.cs
index 8fd96dba4c91..116cf809b51d 100644
--- a/tests/src/JIT/HardwareIntrinsics/General/Vector64_1/Zero.Int16.cs
+++ b/tests/src/JIT/HardwareIntrinsics/General/Vector64_1/Zero.Int16.cs
@@ -73,20 +73,24 @@ private void ValidateResult(Vector64<Int16> result, [CallerMemberName] string me
 
         private void ValidateResult(Int16[] resultElements, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+        
             for (var i = 0; i < ElementCount; i++)
             {
                 if (resultElements[i] != 0)
                 {
-                    Succeeded = false;
+                    succeeded = false;
                     break;
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"Vector64.Zero(Int16): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", resultElements)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/General/Vector64_1/Zero.Int32.cs b/tests/src/JIT/HardwareIntrinsics/General/Vector64_1/Zero.Int32.cs
index 2039681a3e57..04132d171b75 100644
--- a/tests/src/JIT/HardwareIntrinsics/General/Vector64_1/Zero.Int32.cs
+++ b/tests/src/JIT/HardwareIntrinsics/General/Vector64_1/Zero.Int32.cs
@@ -73,20 +73,24 @@ private void ValidateResult(Vector64<Int32> result, [CallerMemberName] string me
 
         private void ValidateResult(Int32[] resultElements, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+        
             for (var i = 0; i < ElementCount; i++)
             {
                 if (resultElements[i] != 0)
                 {
-                    Succeeded = false;
+                    succeeded = false;
                     break;
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"Vector64.Zero(Int32): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", resultElements)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/General/Vector64_1/Zero.Int64.cs b/tests/src/JIT/HardwareIntrinsics/General/Vector64_1/Zero.Int64.cs
index 8e428079b908..22e4b6246659 100644
--- a/tests/src/JIT/HardwareIntrinsics/General/Vector64_1/Zero.Int64.cs
+++ b/tests/src/JIT/HardwareIntrinsics/General/Vector64_1/Zero.Int64.cs
@@ -73,20 +73,24 @@ private void ValidateResult(Vector64<Int64> result, [CallerMemberName] string me
 
         private void ValidateResult(Int64[] resultElements, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+        
             for (var i = 0; i < ElementCount; i++)
             {
                 if (resultElements[i] != 0)
                 {
-                    Succeeded = false;
+                    succeeded = false;
                     break;
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"Vector64.Zero(Int64): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", resultElements)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/General/Vector64_1/Zero.SByte.cs b/tests/src/JIT/HardwareIntrinsics/General/Vector64_1/Zero.SByte.cs
index e029d33f3bbc..5fd98acdd181 100644
--- a/tests/src/JIT/HardwareIntrinsics/General/Vector64_1/Zero.SByte.cs
+++ b/tests/src/JIT/HardwareIntrinsics/General/Vector64_1/Zero.SByte.cs
@@ -73,20 +73,24 @@ private void ValidateResult(Vector64<SByte> result, [CallerMemberName] string me
 
         private void ValidateResult(SByte[] resultElements, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+        
             for (var i = 0; i < ElementCount; i++)
             {
                 if (resultElements[i] != 0)
                 {
-                    Succeeded = false;
+                    succeeded = false;
                     break;
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"Vector64.Zero(SByte): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", resultElements)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/General/Vector64_1/Zero.Single.cs b/tests/src/JIT/HardwareIntrinsics/General/Vector64_1/Zero.Single.cs
index 9e3d1c961d4c..dfdae42d0cb0 100644
--- a/tests/src/JIT/HardwareIntrinsics/General/Vector64_1/Zero.Single.cs
+++ b/tests/src/JIT/HardwareIntrinsics/General/Vector64_1/Zero.Single.cs
@@ -73,20 +73,24 @@ private void ValidateResult(Vector64<Single> result, [CallerMemberName] string m
 
         private void ValidateResult(Single[] resultElements, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+        
             for (var i = 0; i < ElementCount; i++)
             {
                 if (resultElements[i] != 0)
                 {
-                    Succeeded = false;
+                    succeeded = false;
                     break;
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"Vector64.Zero(Single): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", resultElements)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/General/Vector64_1/Zero.UInt16.cs b/tests/src/JIT/HardwareIntrinsics/General/Vector64_1/Zero.UInt16.cs
index 9bf1231d2fc0..41532e32c7c7 100644
--- a/tests/src/JIT/HardwareIntrinsics/General/Vector64_1/Zero.UInt16.cs
+++ b/tests/src/JIT/HardwareIntrinsics/General/Vector64_1/Zero.UInt16.cs
@@ -73,20 +73,24 @@ private void ValidateResult(Vector64<UInt16> result, [CallerMemberName] string m
 
         private void ValidateResult(UInt16[] resultElements, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+        
             for (var i = 0; i < ElementCount; i++)
             {
                 if (resultElements[i] != 0)
                 {
-                    Succeeded = false;
+                    succeeded = false;
                     break;
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"Vector64.Zero(UInt16): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", resultElements)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/General/Vector64_1/Zero.UInt32.cs b/tests/src/JIT/HardwareIntrinsics/General/Vector64_1/Zero.UInt32.cs
index 971d9e14cbb6..1982334fae72 100644
--- a/tests/src/JIT/HardwareIntrinsics/General/Vector64_1/Zero.UInt32.cs
+++ b/tests/src/JIT/HardwareIntrinsics/General/Vector64_1/Zero.UInt32.cs
@@ -73,20 +73,24 @@ private void ValidateResult(Vector64<UInt32> result, [CallerMemberName] string m
 
         private void ValidateResult(UInt32[] resultElements, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+        
             for (var i = 0; i < ElementCount; i++)
             {
                 if (resultElements[i] != 0)
                 {
-                    Succeeded = false;
+                    succeeded = false;
                     break;
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"Vector64.Zero(UInt32): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", resultElements)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/General/Vector64_1/Zero.UInt64.cs b/tests/src/JIT/HardwareIntrinsics/General/Vector64_1/Zero.UInt64.cs
index efb6b62fdabc..8adc50b27c7b 100644
--- a/tests/src/JIT/HardwareIntrinsics/General/Vector64_1/Zero.UInt64.cs
+++ b/tests/src/JIT/HardwareIntrinsics/General/Vector64_1/Zero.UInt64.cs
@@ -73,20 +73,24 @@ private void ValidateResult(Vector64<UInt64> result, [CallerMemberName] string m
 
         private void ValidateResult(UInt64[] resultElements, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+        
             for (var i = 0; i < ElementCount; i++)
             {
                 if (resultElements[i] != 0)
                 {
-                    Succeeded = false;
+                    succeeded = false;
                     break;
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"Vector64.Zero(UInt64): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", resultElements)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Aes/Decrypt.Byte.cs b/tests/src/JIT/HardwareIntrinsics/X86/Aes/Decrypt.Byte.cs
index 1a4a0d184eb6..1adb5a6e2bbc 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Aes/Decrypt.Byte.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Aes/Decrypt.Byte.cs
@@ -330,7 +330,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -338,7 +338,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -355,19 +360,24 @@ private void ValidateResult(void* result, [CallerMemberName] string method = "")
         
         private void ValidateResult(Byte[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             for (int i = 0; i < result.Length; i++)
             {
                 if (result[i] != _expectedRet[i] )
                 {
-                    Succeeded = false;
+                    succeeded = false;
                 } 
             }
-            if (!Succeeded)
+
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Aes)}.{nameof(Aes.Decrypt)}<Byte>(Vector128<Byte>, Vector128<Byte>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"  expectedRet: ({string.Join(", ", _expectedRet)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Aes/DecryptLast.Byte.cs b/tests/src/JIT/HardwareIntrinsics/X86/Aes/DecryptLast.Byte.cs
index b8e76e313044..618de7633e99 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Aes/DecryptLast.Byte.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Aes/DecryptLast.Byte.cs
@@ -330,7 +330,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -338,7 +338,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -355,19 +360,24 @@ private void ValidateResult(void* result, [CallerMemberName] string method = "")
         
         private void ValidateResult(Byte[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             for (int i = 0; i < result.Length; i++)
             {
                 if (result[i] != _expectedRet[i] )
                 {
-                    Succeeded = false;
+                    succeeded = false;
                 } 
             }
-            if (!Succeeded)
+
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Aes)}.{nameof(Aes.DecryptLast)}<Byte>(Vector128<Byte>, Vector128<Byte>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"  expectedRet: ({string.Join(", ", _expectedRet)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Aes/Encrypt.Byte.cs b/tests/src/JIT/HardwareIntrinsics/X86/Aes/Encrypt.Byte.cs
index 3d72a0f052d5..712c6e76bb9b 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Aes/Encrypt.Byte.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Aes/Encrypt.Byte.cs
@@ -330,7 +330,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -338,7 +338,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -355,19 +360,24 @@ private void ValidateResult(void* result, [CallerMemberName] string method = "")
         
         private void ValidateResult(Byte[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             for (int i = 0; i < result.Length; i++)
             {
                 if (result[i] != _expectedRet[i] )
                 {
-                    Succeeded = false;
+                    succeeded = false;
                 } 
             }
-            if (!Succeeded)
+
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Aes)}.{nameof(Aes.Encrypt)}<Byte>(Vector128<Byte>, Vector128<Byte>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"  expectedRet: ({string.Join(", ", _expectedRet)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Aes/EncryptLast.Byte.cs b/tests/src/JIT/HardwareIntrinsics/X86/Aes/EncryptLast.Byte.cs
index e6a79f92eace..3bb63e604702 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Aes/EncryptLast.Byte.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Aes/EncryptLast.Byte.cs
@@ -330,7 +330,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -338,7 +338,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -355,19 +360,24 @@ private void ValidateResult(void* result, [CallerMemberName] string method = "")
         
         private void ValidateResult(Byte[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             for (int i = 0; i < result.Length; i++)
             {
                 if (result[i] != _expectedRet[i] )
                 {
-                    Succeeded = false;
+                    succeeded = false;
                 } 
             }
-            if (!Succeeded)
+
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Aes)}.{nameof(Aes.EncryptLast)}<Byte>(Vector128<Byte>, Vector128<Byte>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"  expectedRet: ({string.Join(", ", _expectedRet)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Aes/InverseMixColumns.Byte.cs b/tests/src/JIT/HardwareIntrinsics/X86/Aes/InverseMixColumns.Byte.cs
index 9a5b8c302d50..ec15cd2416fb 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Aes/InverseMixColumns.Byte.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Aes/InverseMixColumns.Byte.cs
@@ -310,7 +310,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -318,7 +318,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -335,21 +340,25 @@ private void ValidateResult(void* result, [CallerMemberName] string method = "")
 
         private void ValidateResult(Byte[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             for (int i = 0; i < result.Length; i++)
             {
                 if (result[i] != _expectedRet[i] )
                 {
-                    Succeeded = false;
-		    break;
+                    succeeded = false;
+                    break;
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Aes)}.{nameof(Aes.InverseMixColumns)}<Byte>(Vector128<Byte>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"  expectedRet: ({string.Join(", ", _expectedRet)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Aes/KeygenAssist.Byte.5.cs b/tests/src/JIT/HardwareIntrinsics/X86/Aes/KeygenAssist.Byte.5.cs
index 4b8be2a18192..4e675d2a206d 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Aes/KeygenAssist.Byte.5.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Aes/KeygenAssist.Byte.5.cs
@@ -317,7 +317,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -325,7 +325,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -341,21 +346,25 @@ private void ValidateResult(void* result, [CallerMemberName] string method = "")
 
         private void ValidateResult(Byte[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             for (int i = 0; i < result.Length; i++)
             {
                 if (result[i] != _expectedRet[i] )
-                    {
-                        Succeeded = false;
-		    	break;
-                    }
+                {
+                    succeeded = false;
+                    break;
+                }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Aes)}.{nameof(Aes.KeygenAssist)}<Byte>(Vector128<Byte>, 5): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"  expectedRet: ({string.Join(", ", _expectedRet)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx/Add.Double.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx/Add.Double.cs
index 24fb9fb3e826..f04815757cf0 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Avx/Add.Double.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx/Add.Double.cs
@@ -334,7 +334,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -342,7 +342,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -374,9 +379,11 @@ private void ValidateResult(void* left, void* right, void* result, [CallerMember
 
         private void ValidateResult(Double[] left, Double[] right, Double[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (BitConverter.DoubleToInt64Bits(left[0] + right[0]) != BitConverter.DoubleToInt64Bits(result[0]))
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -384,19 +391,21 @@ private void ValidateResult(Double[] left, Double[] right, Double[] result, [Cal
                 {
                     if (BitConverter.DoubleToInt64Bits(left[i] + right[i]) != BitConverter.DoubleToInt64Bits(result[i]))
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Avx)}.{nameof(Avx.Add)}<Double>(Vector256<Double>, Vector256<Double>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx/Add.Single.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx/Add.Single.cs
index 01f2db0874de..1abc3678cfc1 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Avx/Add.Single.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx/Add.Single.cs
@@ -334,7 +334,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -342,7 +342,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -374,9 +379,11 @@ private void ValidateResult(void* left, void* right, void* result, [CallerMember
 
         private void ValidateResult(Single[] left, Single[] right, Single[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (BitConverter.SingleToInt32Bits(left[0] + right[0]) != BitConverter.SingleToInt32Bits(result[0]))
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -384,19 +391,21 @@ private void ValidateResult(Single[] left, Single[] right, Single[] result, [Cal
                 {
                     if (BitConverter.SingleToInt32Bits(left[i] + right[i]) != BitConverter.SingleToInt32Bits(result[i]))
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Avx)}.{nameof(Avx.Add)}<Single>(Vector256<Single>, Vector256<Single>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx/AddSubtract.Double.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx/AddSubtract.Double.cs
index 758d91f618c3..1ba30104708b 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Avx/AddSubtract.Double.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx/AddSubtract.Double.cs
@@ -334,7 +334,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -342,7 +342,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -374,9 +379,11 @@ private void ValidateResult(void* left, void* right, void* result, [CallerMember
 
         private void ValidateResult(Double[] left, Double[] right, Double[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (BitConverter.DoubleToInt64Bits(left[0] - right[0]) != BitConverter.DoubleToInt64Bits(result[0]))
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -384,19 +391,21 @@ private void ValidateResult(Double[] left, Double[] right, Double[] result, [Cal
                 {
                     if (((i % 2 != 0) && (BitConverter.DoubleToInt64Bits(left[i] + right[i]) != BitConverter.DoubleToInt64Bits(result[i]))) || ((i % 2 == 0) && (BitConverter.DoubleToInt64Bits(left[i] - right[i]) != BitConverter.DoubleToInt64Bits(result[i]))))
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Avx)}.{nameof(Avx.AddSubtract)}<Double>(Vector256<Double>, Vector256<Double>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx/AddSubtract.Single.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx/AddSubtract.Single.cs
index c6eb8db6f635..775093781d35 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Avx/AddSubtract.Single.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx/AddSubtract.Single.cs
@@ -334,7 +334,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -342,7 +342,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -374,9 +379,11 @@ private void ValidateResult(void* left, void* right, void* result, [CallerMember
 
         private void ValidateResult(Single[] left, Single[] right, Single[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (BitConverter.SingleToInt32Bits(left[0] - right[0]) != BitConverter.SingleToInt32Bits(result[0]))
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -384,19 +391,21 @@ private void ValidateResult(Single[] left, Single[] right, Single[] result, [Cal
                 {
                     if (((i % 2 != 0) && (BitConverter.SingleToInt32Bits(left[i] + right[i]) != BitConverter.SingleToInt32Bits(result[i]))) || ((i % 2 == 0) && (BitConverter.SingleToInt32Bits(left[i] - right[i]) != BitConverter.SingleToInt32Bits(result[i]))))
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Avx)}.{nameof(Avx.AddSubtract)}<Single>(Vector256<Single>, Vector256<Single>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx/And.Double.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx/And.Double.cs
index f207fe2c8c74..23cada308a51 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Avx/And.Double.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx/And.Double.cs
@@ -334,7 +334,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -342,7 +342,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -374,9 +379,11 @@ private void ValidateResult(void* left, void* right, void* result, [CallerMember
 
         private void ValidateResult(Double[] left, Double[] right, Double[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if ((BitConverter.DoubleToInt64Bits(left[0]) & BitConverter.DoubleToInt64Bits(right[0])) != BitConverter.DoubleToInt64Bits(result[0]))
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -384,19 +391,21 @@ private void ValidateResult(Double[] left, Double[] right, Double[] result, [Cal
                 {
                     if ((BitConverter.DoubleToInt64Bits(left[i]) & BitConverter.DoubleToInt64Bits(right[i])) != BitConverter.DoubleToInt64Bits(result[i]))
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Avx)}.{nameof(Avx.And)}<Double>(Vector256<Double>, Vector256<Double>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx/And.Single.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx/And.Single.cs
index 29798455d115..a097bbce838c 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Avx/And.Single.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx/And.Single.cs
@@ -334,7 +334,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -342,7 +342,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -374,9 +379,11 @@ private void ValidateResult(void* left, void* right, void* result, [CallerMember
 
         private void ValidateResult(Single[] left, Single[] right, Single[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if ((BitConverter.SingleToInt32Bits(left[0]) & BitConverter.SingleToInt32Bits(right[0])) != BitConverter.SingleToInt32Bits(result[0]))
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -384,19 +391,21 @@ private void ValidateResult(Single[] left, Single[] right, Single[] result, [Cal
                 {
                     if ((BitConverter.SingleToInt32Bits(left[i]) & BitConverter.SingleToInt32Bits(right[i])) != BitConverter.SingleToInt32Bits(result[i]))
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Avx)}.{nameof(Avx.And)}<Single>(Vector256<Single>, Vector256<Single>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx/AndNot.Double.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx/AndNot.Double.cs
index bc5b294c9466..3423639ffbfd 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Avx/AndNot.Double.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx/AndNot.Double.cs
@@ -334,7 +334,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -342,7 +342,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -374,9 +379,11 @@ private void ValidateResult(void* left, void* right, void* result, [CallerMember
 
         private void ValidateResult(Double[] left, Double[] right, Double[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (((~BitConverter.DoubleToInt64Bits(left[0])) & BitConverter.DoubleToInt64Bits(right[0])) != BitConverter.DoubleToInt64Bits(result[0]))
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -384,19 +391,21 @@ private void ValidateResult(Double[] left, Double[] right, Double[] result, [Cal
                 {
                     if (((~BitConverter.DoubleToInt64Bits(left[i])) & BitConverter.DoubleToInt64Bits(right[i])) != BitConverter.DoubleToInt64Bits(result[i]))
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Avx)}.{nameof(Avx.AndNot)}<Double>(Vector256<Double>, Vector256<Double>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx/AndNot.Single.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx/AndNot.Single.cs
index 987e1a52e465..3fed1f078d91 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Avx/AndNot.Single.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx/AndNot.Single.cs
@@ -334,7 +334,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -342,7 +342,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -374,9 +379,11 @@ private void ValidateResult(void* left, void* right, void* result, [CallerMember
 
         private void ValidateResult(Single[] left, Single[] right, Single[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (((~BitConverter.SingleToInt32Bits(left[0])) & BitConverter.SingleToInt32Bits(right[0])) != BitConverter.SingleToInt32Bits(result[0]))
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -384,19 +391,21 @@ private void ValidateResult(Single[] left, Single[] right, Single[] result, [Cal
                 {
                     if (((~BitConverter.SingleToInt32Bits(left[i])) & BitConverter.SingleToInt32Bits(right[i])) != BitConverter.SingleToInt32Bits(result[i]))
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Avx)}.{nameof(Avx.AndNot)}<Single>(Vector256<Single>, Vector256<Single>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx/BlendVariable.Double.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx/BlendVariable.Double.cs
index fa14505457d3..269d7db36dbd 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Avx/BlendVariable.Double.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx/BlendVariable.Double.cs
@@ -356,7 +356,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -364,7 +364,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -400,9 +405,11 @@ private void ValidateResult(void* firstOp, void* secondOp, void* thirdOp, void*
 
         private void ValidateResult(Double[] firstOp, Double[] secondOp, Double[] thirdOp, Double[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (((BitConverter.DoubleToInt64Bits(thirdOp[0]) >> 63) & 1) == 1 ? BitConverter.DoubleToInt64Bits(secondOp[0]) != BitConverter.DoubleToInt64Bits(result[0]) : BitConverter.DoubleToInt64Bits(firstOp[0]) != BitConverter.DoubleToInt64Bits(result[0]))
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -410,13 +417,13 @@ private void ValidateResult(Double[] firstOp, Double[] secondOp, Double[] thirdO
                 {
                     if (((BitConverter.DoubleToInt64Bits(thirdOp[i]) >> 63) & 1) == 1 ? BitConverter.DoubleToInt64Bits(secondOp[i]) != BitConverter.DoubleToInt64Bits(result[i]) : BitConverter.DoubleToInt64Bits(firstOp[i]) != BitConverter.DoubleToInt64Bits(result[i]))
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Avx)}.{nameof(Avx.BlendVariable)}<Double>(Vector256<Double>, Vector256<Double>, Vector256<Double>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"   firstOp: ({string.Join(", ", firstOp)})");
@@ -424,6 +431,8 @@ private void ValidateResult(Double[] firstOp, Double[] secondOp, Double[] thirdO
                 TestLibrary.TestFramework.LogInformation($"   thirdOp: ({string.Join(", ", thirdOp)})");
                 TestLibrary.TestFramework.LogInformation($"    result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx/BlendVariable.Single.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx/BlendVariable.Single.cs
index fafd6452355e..d8dd9e36c566 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Avx/BlendVariable.Single.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx/BlendVariable.Single.cs
@@ -356,7 +356,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -364,7 +364,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -400,9 +405,11 @@ private void ValidateResult(void* firstOp, void* secondOp, void* thirdOp, void*
 
         private void ValidateResult(Single[] firstOp, Single[] secondOp, Single[] thirdOp, Single[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (((BitConverter.SingleToInt32Bits(thirdOp[0]) >> 31) & 1) == 1 ? BitConverter.SingleToInt32Bits(secondOp[0]) != BitConverter.SingleToInt32Bits(result[0]) : BitConverter.SingleToInt32Bits(firstOp[0]) != BitConverter.SingleToInt32Bits(result[0]))
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -410,13 +417,13 @@ private void ValidateResult(Single[] firstOp, Single[] secondOp, Single[] thirdO
                 {
                     if (((BitConverter.SingleToInt32Bits(thirdOp[i]) >> 31) & 1) == 1 ? BitConverter.SingleToInt32Bits(secondOp[i]) != BitConverter.SingleToInt32Bits(result[i]) : BitConverter.SingleToInt32Bits(firstOp[i]) != BitConverter.SingleToInt32Bits(result[i]))
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Avx)}.{nameof(Avx.BlendVariable)}<Single>(Vector256<Single>, Vector256<Single>, Vector256<Single>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"   firstOp: ({string.Join(", ", firstOp)})");
@@ -424,6 +431,8 @@ private void ValidateResult(Single[] firstOp, Single[] secondOp, Single[] thirdO
                 TestLibrary.TestFramework.LogInformation($"   thirdOp: ({string.Join(", ", thirdOp)})");
                 TestLibrary.TestFramework.LogInformation($"    result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx/BroadcastScalarToVector128.Single.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx/BroadcastScalarToVector128.Single.cs
index 9e0ebc8f9dbe..88fe4f8013a2 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Avx/BroadcastScalarToVector128.Single.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx/BroadcastScalarToVector128.Single.cs
@@ -133,9 +133,11 @@ private void ValidateResult(void* firstOp, void* result, [CallerMemberName] stri
 
         private void ValidateResult(Single[] firstOp, Single[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (BitConverter.SingleToInt32Bits(firstOp[0]) != BitConverter.SingleToInt32Bits(result[0]))
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -143,18 +145,20 @@ private void ValidateResult(Single[] firstOp, Single[] result, [CallerMemberName
                 {
                     if (BitConverter.SingleToInt32Bits(firstOp[0]) != BitConverter.SingleToInt32Bits(result[i]))
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Avx)}.{nameof(Avx.BroadcastScalarToVector128)}<Single>(Vector128<Single>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"  firstOp: ({string.Join(", ", firstOp)})");
                 TestLibrary.TestFramework.LogInformation($"   result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx/BroadcastScalarToVector256.Double.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx/BroadcastScalarToVector256.Double.cs
index 248313aa11e4..feae5a6c4927 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Avx/BroadcastScalarToVector256.Double.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx/BroadcastScalarToVector256.Double.cs
@@ -133,9 +133,11 @@ private void ValidateResult(void* firstOp, void* result, [CallerMemberName] stri
 
         private void ValidateResult(Double[] firstOp, Double[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (BitConverter.DoubleToInt64Bits(firstOp[0]) != BitConverter.DoubleToInt64Bits(result[0]))
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -143,18 +145,20 @@ private void ValidateResult(Double[] firstOp, Double[] result, [CallerMemberName
                 {
                     if (BitConverter.DoubleToInt64Bits(firstOp[0]) != BitConverter.DoubleToInt64Bits(result[i]))
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Avx)}.{nameof(Avx.BroadcastScalarToVector256)}<Double>(Vector128<Double>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"  firstOp: ({string.Join(", ", firstOp)})");
                 TestLibrary.TestFramework.LogInformation($"   result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx/BroadcastScalarToVector256.Single.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx/BroadcastScalarToVector256.Single.cs
index 6966f548e2ae..73488dee2601 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Avx/BroadcastScalarToVector256.Single.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx/BroadcastScalarToVector256.Single.cs
@@ -133,9 +133,11 @@ private void ValidateResult(void* firstOp, void* result, [CallerMemberName] stri
 
         private void ValidateResult(Single[] firstOp, Single[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (BitConverter.SingleToInt32Bits(firstOp[0]) != BitConverter.SingleToInt32Bits(result[0]))
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -143,18 +145,20 @@ private void ValidateResult(Single[] firstOp, Single[] result, [CallerMemberName
                 {
                     if (BitConverter.SingleToInt32Bits(firstOp[0]) != BitConverter.SingleToInt32Bits(result[i]))
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Avx)}.{nameof(Avx.BroadcastScalarToVector256)}<Single>(Vector128<Single>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"  firstOp: ({string.Join(", ", firstOp)})");
                 TestLibrary.TestFramework.LogInformation($"   result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx/BroadcastVector128ToVector256.Double.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx/BroadcastVector128ToVector256.Double.cs
index 97579e60f462..765f3645026c 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Avx/BroadcastVector128ToVector256.Double.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx/BroadcastVector128ToVector256.Double.cs
@@ -133,9 +133,11 @@ private void ValidateResult(void* firstOp, void* result, [CallerMemberName] stri
 
         private void ValidateResult(Double[] firstOp, Double[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (BitConverter.DoubleToInt64Bits(firstOp[0]) != BitConverter.DoubleToInt64Bits(result[0]))
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -143,18 +145,20 @@ private void ValidateResult(Double[] firstOp, Double[] result, [CallerMemberName
                 {
                     if (BitConverter.DoubleToInt64Bits(result[i]) != (i < 2 ? BitConverter.DoubleToInt64Bits(firstOp[i]) : BitConverter.DoubleToInt64Bits(firstOp[i-2])))
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Avx)}.{nameof(Avx.BroadcastVector128ToVector256)}<Double>(Vector128<Double>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"  firstOp: ({string.Join(", ", firstOp)})");
                 TestLibrary.TestFramework.LogInformation($"   result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx/BroadcastVector128ToVector256.Single.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx/BroadcastVector128ToVector256.Single.cs
index e32fb1a7fd62..49c49a40536c 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Avx/BroadcastVector128ToVector256.Single.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx/BroadcastVector128ToVector256.Single.cs
@@ -133,9 +133,11 @@ private void ValidateResult(void* firstOp, void* result, [CallerMemberName] stri
 
         private void ValidateResult(Single[] firstOp, Single[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (BitConverter.SingleToInt32Bits(firstOp[0]) != BitConverter.SingleToInt32Bits(result[0]))
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -143,18 +145,20 @@ private void ValidateResult(Single[] firstOp, Single[] result, [CallerMemberName
                 {
                     if (BitConverter.SingleToInt32Bits(result[i]) != (i < 4 ? BitConverter.SingleToInt32Bits(firstOp[i]) : BitConverter.SingleToInt32Bits(firstOp[i-4])))
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Avx)}.{nameof(Avx.BroadcastVector128ToVector256)}<Single>(Vector128<Single>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"  firstOp: ({string.Join(", ", firstOp)})");
                 TestLibrary.TestFramework.LogInformation($"   result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx/Ceiling.Double.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx/Ceiling.Double.cs
index 8c311e3f0e6a..985ddeb20ca2 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Avx/Ceiling.Double.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx/Ceiling.Double.cs
@@ -312,7 +312,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -320,7 +320,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -348,9 +353,11 @@ private void ValidateResult(void* firstOp, void* result, [CallerMemberName] stri
 
         private void ValidateResult(Double[] firstOp, Double[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (BitConverter.DoubleToInt64Bits(result[0]) != BitConverter.DoubleToInt64Bits(Math.Ceiling(firstOp[0])))
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -358,18 +365,20 @@ private void ValidateResult(Double[] firstOp, Double[] result, [CallerMemberName
                 {
                     if (BitConverter.DoubleToInt64Bits(result[i]) != BitConverter.DoubleToInt64Bits(Math.Ceiling(firstOp[i])))
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Avx)}.{nameof(Avx.Ceiling)}<Double>(Vector256<Double>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"  firstOp: ({string.Join(", ", firstOp)})");
                 TestLibrary.TestFramework.LogInformation($"   result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx/Ceiling.Single.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx/Ceiling.Single.cs
index 1462f4f5a3a1..ee2fd1c5ca48 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Avx/Ceiling.Single.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx/Ceiling.Single.cs
@@ -312,7 +312,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -320,7 +320,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -348,9 +353,11 @@ private void ValidateResult(void* firstOp, void* result, [CallerMemberName] stri
 
         private void ValidateResult(Single[] firstOp, Single[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (BitConverter.SingleToInt32Bits(result[0]) != BitConverter.SingleToInt32Bits(MathF.Ceiling(firstOp[0])))
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -358,18 +365,20 @@ private void ValidateResult(Single[] firstOp, Single[] result, [CallerMemberName
                 {
                     if (BitConverter.SingleToInt32Bits(result[i]) != BitConverter.SingleToInt32Bits(MathF.Ceiling(firstOp[i])))
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Avx)}.{nameof(Avx.Ceiling)}<Single>(Vector256<Single>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"  firstOp: ({string.Join(", ", firstOp)})");
                 TestLibrary.TestFramework.LogInformation($"   result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx/Divide.Double.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx/Divide.Double.cs
index 72d2491a2b3e..5a366dc274f9 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Avx/Divide.Double.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx/Divide.Double.cs
@@ -334,7 +334,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -342,7 +342,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -374,9 +379,11 @@ private void ValidateResult(void* left, void* right, void* result, [CallerMember
 
         private void ValidateResult(Double[] left, Double[] right, Double[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (BitConverter.DoubleToInt64Bits(left[0] / right[0]) != BitConverter.DoubleToInt64Bits(result[0]))
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -384,19 +391,21 @@ private void ValidateResult(Double[] left, Double[] right, Double[] result, [Cal
                 {
                     if (BitConverter.DoubleToInt64Bits(left[i] / right[i]) != BitConverter.DoubleToInt64Bits(result[i]))
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Avx)}.{nameof(Avx.Divide)}<Double>(Vector256<Double>, Vector256<Double>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx/Divide.Single.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx/Divide.Single.cs
index 71be74228138..f3adbda25521 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Avx/Divide.Single.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx/Divide.Single.cs
@@ -334,7 +334,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -342,7 +342,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -374,9 +379,11 @@ private void ValidateResult(void* left, void* right, void* result, [CallerMember
 
         private void ValidateResult(Single[] left, Single[] right, Single[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (BitConverter.SingleToInt32Bits(left[0] / right[0]) != BitConverter.SingleToInt32Bits(result[0]))
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -384,19 +391,21 @@ private void ValidateResult(Single[] left, Single[] right, Single[] result, [Cal
                 {
                     if (BitConverter.SingleToInt32Bits(left[i] / right[i]) != BitConverter.SingleToInt32Bits(result[i]))
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Avx)}.{nameof(Avx.Divide)}<Single>(Vector256<Single>, Vector256<Single>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx/DuplicateEvenIndexed.Double.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx/DuplicateEvenIndexed.Double.cs
index 8108e7f5dcf7..fefeacf439eb 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Avx/DuplicateEvenIndexed.Double.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx/DuplicateEvenIndexed.Double.cs
@@ -312,7 +312,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -320,7 +320,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -348,9 +353,11 @@ private void ValidateResult(void* firstOp, void* result, [CallerMemberName] stri
 
         private void ValidateResult(Double[] firstOp, Double[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (BitConverter.DoubleToInt64Bits(firstOp[0]) != BitConverter.DoubleToInt64Bits(result[0]))
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -358,18 +365,20 @@ private void ValidateResult(Double[] firstOp, Double[] result, [CallerMemberName
                 {
                     if ((i % 2 == 0) ? (BitConverter.DoubleToInt64Bits(firstOp[i]) != BitConverter.DoubleToInt64Bits(result[i])) : (BitConverter.DoubleToInt64Bits(firstOp[i - 1]) != BitConverter.DoubleToInt64Bits(result[i])))
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Avx)}.{nameof(Avx.DuplicateEvenIndexed)}<Double>(Vector256<Double>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"  firstOp: ({string.Join(", ", firstOp)})");
                 TestLibrary.TestFramework.LogInformation($"   result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx/DuplicateEvenIndexed.Single.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx/DuplicateEvenIndexed.Single.cs
index 58114a75ee71..0d98f6aa2e95 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Avx/DuplicateEvenIndexed.Single.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx/DuplicateEvenIndexed.Single.cs
@@ -312,7 +312,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -320,7 +320,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -348,9 +353,11 @@ private void ValidateResult(void* firstOp, void* result, [CallerMemberName] stri
 
         private void ValidateResult(Single[] firstOp, Single[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (BitConverter.SingleToInt32Bits(firstOp[0]) != BitConverter.SingleToInt32Bits(result[0]))
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -358,18 +365,20 @@ private void ValidateResult(Single[] firstOp, Single[] result, [CallerMemberName
                 {
                     if ((i % 2 == 0) ? (BitConverter.SingleToInt32Bits(firstOp[i]) != BitConverter.SingleToInt32Bits(result[i])) : (BitConverter.SingleToInt32Bits(firstOp[i - 1]) != BitConverter.SingleToInt32Bits(result[i])))
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Avx)}.{nameof(Avx.DuplicateEvenIndexed)}<Single>(Vector256<Single>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"  firstOp: ({string.Join(", ", firstOp)})");
                 TestLibrary.TestFramework.LogInformation($"   result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx/DuplicateOddIndexed.Single.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx/DuplicateOddIndexed.Single.cs
index 1f550d897260..e2e81640a752 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Avx/DuplicateOddIndexed.Single.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx/DuplicateOddIndexed.Single.cs
@@ -312,7 +312,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -320,7 +320,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -348,9 +353,11 @@ private void ValidateResult(void* firstOp, void* result, [CallerMemberName] stri
 
         private void ValidateResult(Single[] firstOp, Single[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (BitConverter.SingleToInt32Bits(firstOp[1]) != BitConverter.SingleToInt32Bits(result[0]))
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -358,18 +365,20 @@ private void ValidateResult(Single[] firstOp, Single[] result, [CallerMemberName
                 {
                     if ((i % 2 == 0) ? (BitConverter.SingleToInt32Bits(firstOp[i + 1]) != BitConverter.SingleToInt32Bits(result[i])) : (BitConverter.SingleToInt32Bits(firstOp[i]) != BitConverter.SingleToInt32Bits(result[i])))
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Avx)}.{nameof(Avx.DuplicateOddIndexed)}<Single>(Vector256<Single>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"  firstOp: ({string.Join(", ", firstOp)})");
                 TestLibrary.TestFramework.LogInformation($"   result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx/ExtractVector128.Byte.1.Store.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx/ExtractVector128.Byte.1.Store.cs
index 7c2ea2696f0e..3e42e55283b2 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Avx/ExtractVector128.Byte.1.Store.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx/ExtractVector128.Byte.1.Store.cs
@@ -306,7 +306,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -314,7 +314,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -342,9 +347,11 @@ private void ValidateResult(void* firstOp, void* result, [CallerMemberName] stri
 
         private void ValidateResult(Byte[] firstOp, Byte[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (result[0] != firstOp[16])
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -352,18 +359,20 @@ private void ValidateResult(Byte[] firstOp, Byte[] result, [CallerMemberName] st
                 {
                     if ((result[i] != firstOp[i + 16]))
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Avx)}.{nameof(Avx.ExtractVector128)}<Byte>(Vector256<Byte><9>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"  firstOp: ({string.Join(", ", firstOp)})");
                 TestLibrary.TestFramework.LogInformation($"   result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx/ExtractVector128.Byte.1.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx/ExtractVector128.Byte.1.cs
index f6fbd1d674ad..ea0e27f965a3 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Avx/ExtractVector128.Byte.1.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx/ExtractVector128.Byte.1.cs
@@ -319,7 +319,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -327,7 +327,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -355,9 +360,11 @@ private void ValidateResult(void* firstOp, void* result, [CallerMemberName] stri
 
         private void ValidateResult(Byte[] firstOp, Byte[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (result[0] != firstOp[16])
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -365,18 +372,20 @@ private void ValidateResult(Byte[] firstOp, Byte[] result, [CallerMemberName] st
                 {
                     if (result[i] != firstOp[i+16])
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Avx)}.{nameof(Avx.ExtractVector128)}<Byte>(Vector256<Byte><9>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"  firstOp: ({string.Join(", ", firstOp)})");
                 TestLibrary.TestFramework.LogInformation($"   result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx/ExtractVector128.Double.1.Store.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx/ExtractVector128.Double.1.Store.cs
index 950b7316226b..5b26a53e8473 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Avx/ExtractVector128.Double.1.Store.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx/ExtractVector128.Double.1.Store.cs
@@ -306,7 +306,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -314,7 +314,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -342,9 +347,11 @@ private void ValidateResult(void* firstOp, void* result, [CallerMemberName] stri
 
         private void ValidateResult(Double[] firstOp, Double[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (BitConverter.DoubleToInt64Bits(result[0]) != BitConverter.DoubleToInt64Bits(firstOp[2]))
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -352,18 +359,20 @@ private void ValidateResult(Double[] firstOp, Double[] result, [CallerMemberName
                 {
                     if ((BitConverter.DoubleToInt64Bits(result[i]) != BitConverter.DoubleToInt64Bits(firstOp[i + 2])))
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Avx)}.{nameof(Avx.ExtractVector128)}<Double>(Vector256<Double><9>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"  firstOp: ({string.Join(", ", firstOp)})");
                 TestLibrary.TestFramework.LogInformation($"   result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx/ExtractVector128.Double.1.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx/ExtractVector128.Double.1.cs
index 02e22d97141e..4e7a8f5fff18 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Avx/ExtractVector128.Double.1.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx/ExtractVector128.Double.1.cs
@@ -319,7 +319,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -327,7 +327,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -355,9 +360,11 @@ private void ValidateResult(void* firstOp, void* result, [CallerMemberName] stri
 
         private void ValidateResult(Double[] firstOp, Double[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (BitConverter.DoubleToInt64Bits(result[0]) != BitConverter.DoubleToInt64Bits(firstOp[2]))
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -365,18 +372,20 @@ private void ValidateResult(Double[] firstOp, Double[] result, [CallerMemberName
                 {
                     if (BitConverter.DoubleToInt64Bits(result[i]) != BitConverter.DoubleToInt64Bits(firstOp[i+2]))
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Avx)}.{nameof(Avx.ExtractVector128)}<Double>(Vector256<Double><9>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"  firstOp: ({string.Join(", ", firstOp)})");
                 TestLibrary.TestFramework.LogInformation($"   result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx/ExtractVector128.Int16.1.Store.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx/ExtractVector128.Int16.1.Store.cs
index 3fe4b176da13..1a3fb5566f86 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Avx/ExtractVector128.Int16.1.Store.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx/ExtractVector128.Int16.1.Store.cs
@@ -306,7 +306,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -314,7 +314,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -342,9 +347,11 @@ private void ValidateResult(void* firstOp, void* result, [CallerMemberName] stri
 
         private void ValidateResult(Int16[] firstOp, Int16[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (result[0] != firstOp[8])
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -352,18 +359,20 @@ private void ValidateResult(Int16[] firstOp, Int16[] result, [CallerMemberName]
                 {
                     if ((result[i] != firstOp[i + 8]))
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Avx)}.{nameof(Avx.ExtractVector128)}<Int16>(Vector256<Int16><9>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"  firstOp: ({string.Join(", ", firstOp)})");
                 TestLibrary.TestFramework.LogInformation($"   result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx/ExtractVector128.Int16.1.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx/ExtractVector128.Int16.1.cs
index 0b4314456ffd..9954a9f5bcdd 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Avx/ExtractVector128.Int16.1.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx/ExtractVector128.Int16.1.cs
@@ -319,7 +319,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -327,7 +327,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -355,9 +360,11 @@ private void ValidateResult(void* firstOp, void* result, [CallerMemberName] stri
 
         private void ValidateResult(Int16[] firstOp, Int16[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (result[0] != firstOp[8])
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -365,18 +372,20 @@ private void ValidateResult(Int16[] firstOp, Int16[] result, [CallerMemberName]
                 {
                     if (result[i] != firstOp[i+8])
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Avx)}.{nameof(Avx.ExtractVector128)}<Int16>(Vector256<Int16><9>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"  firstOp: ({string.Join(", ", firstOp)})");
                 TestLibrary.TestFramework.LogInformation($"   result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx/ExtractVector128.Int32.1.Store.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx/ExtractVector128.Int32.1.Store.cs
index db9e2c18ae2d..9accfba956e4 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Avx/ExtractVector128.Int32.1.Store.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx/ExtractVector128.Int32.1.Store.cs
@@ -306,7 +306,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -314,7 +314,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -342,9 +347,11 @@ private void ValidateResult(void* firstOp, void* result, [CallerMemberName] stri
 
         private void ValidateResult(Int32[] firstOp, Int32[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (result[0] != firstOp[4])
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -352,18 +359,20 @@ private void ValidateResult(Int32[] firstOp, Int32[] result, [CallerMemberName]
                 {
                     if ((result[i] != firstOp[i + 4]))
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Avx)}.{nameof(Avx.ExtractVector128)}<Int32>(Vector256<Int32><9>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"  firstOp: ({string.Join(", ", firstOp)})");
                 TestLibrary.TestFramework.LogInformation($"   result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx/ExtractVector128.Int32.1.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx/ExtractVector128.Int32.1.cs
index 547a248eec46..35ccf0eb6ff2 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Avx/ExtractVector128.Int32.1.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx/ExtractVector128.Int32.1.cs
@@ -319,7 +319,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -327,7 +327,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -355,9 +360,11 @@ private void ValidateResult(void* firstOp, void* result, [CallerMemberName] stri
 
         private void ValidateResult(Int32[] firstOp, Int32[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (result[0] != firstOp[4])
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -365,18 +372,20 @@ private void ValidateResult(Int32[] firstOp, Int32[] result, [CallerMemberName]
                 {
                     if (result[i] != firstOp[i+4])
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Avx)}.{nameof(Avx.ExtractVector128)}<Int32>(Vector256<Int32><9>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"  firstOp: ({string.Join(", ", firstOp)})");
                 TestLibrary.TestFramework.LogInformation($"   result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx/ExtractVector128.Int64.1.Store.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx/ExtractVector128.Int64.1.Store.cs
index d84e7cf5fbca..d27e00336f23 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Avx/ExtractVector128.Int64.1.Store.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx/ExtractVector128.Int64.1.Store.cs
@@ -306,7 +306,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -314,7 +314,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -342,9 +347,11 @@ private void ValidateResult(void* firstOp, void* result, [CallerMemberName] stri
 
         private void ValidateResult(Int64[] firstOp, Int64[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (result[0] != firstOp[2])
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -352,18 +359,20 @@ private void ValidateResult(Int64[] firstOp, Int64[] result, [CallerMemberName]
                 {
                     if ((result[i] != firstOp[i + 2]))
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Avx)}.{nameof(Avx.ExtractVector128)}<Int64>(Vector256<Int64><9>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"  firstOp: ({string.Join(", ", firstOp)})");
                 TestLibrary.TestFramework.LogInformation($"   result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx/ExtractVector128.Int64.1.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx/ExtractVector128.Int64.1.cs
index 2390ed7e0b7a..bc73e449b7c7 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Avx/ExtractVector128.Int64.1.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx/ExtractVector128.Int64.1.cs
@@ -319,7 +319,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -327,7 +327,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -355,9 +360,11 @@ private void ValidateResult(void* firstOp, void* result, [CallerMemberName] stri
 
         private void ValidateResult(Int64[] firstOp, Int64[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (result[0] != firstOp[2])
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -365,18 +372,20 @@ private void ValidateResult(Int64[] firstOp, Int64[] result, [CallerMemberName]
                 {
                     if (result[i] != firstOp[i+2])
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Avx)}.{nameof(Avx.ExtractVector128)}<Int64>(Vector256<Int64><9>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"  firstOp: ({string.Join(", ", firstOp)})");
                 TestLibrary.TestFramework.LogInformation($"   result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx/ExtractVector128.SByte.1.Store.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx/ExtractVector128.SByte.1.Store.cs
index 1b1080166f21..194eb5159bd2 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Avx/ExtractVector128.SByte.1.Store.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx/ExtractVector128.SByte.1.Store.cs
@@ -306,7 +306,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -314,7 +314,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -342,9 +347,11 @@ private void ValidateResult(void* firstOp, void* result, [CallerMemberName] stri
 
         private void ValidateResult(SByte[] firstOp, SByte[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (result[0] != firstOp[16])
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -352,18 +359,20 @@ private void ValidateResult(SByte[] firstOp, SByte[] result, [CallerMemberName]
                 {
                     if ((result[i] != firstOp[i + 16]))
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Avx)}.{nameof(Avx.ExtractVector128)}<SByte>(Vector256<SByte><9>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"  firstOp: ({string.Join(", ", firstOp)})");
                 TestLibrary.TestFramework.LogInformation($"   result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx/ExtractVector128.SByte.1.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx/ExtractVector128.SByte.1.cs
index f673eb3626a7..3a07a0e558a1 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Avx/ExtractVector128.SByte.1.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx/ExtractVector128.SByte.1.cs
@@ -319,7 +319,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -327,7 +327,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -355,9 +360,11 @@ private void ValidateResult(void* firstOp, void* result, [CallerMemberName] stri
 
         private void ValidateResult(SByte[] firstOp, SByte[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (result[0] != firstOp[16])
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -365,18 +372,20 @@ private void ValidateResult(SByte[] firstOp, SByte[] result, [CallerMemberName]
                 {
                     if (result[i] != firstOp[i+16])
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Avx)}.{nameof(Avx.ExtractVector128)}<SByte>(Vector256<SByte><9>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"  firstOp: ({string.Join(", ", firstOp)})");
                 TestLibrary.TestFramework.LogInformation($"   result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx/ExtractVector128.Single.1.Store.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx/ExtractVector128.Single.1.Store.cs
index 4d947ae9d894..9b4133e2a6bf 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Avx/ExtractVector128.Single.1.Store.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx/ExtractVector128.Single.1.Store.cs
@@ -306,7 +306,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -314,7 +314,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -342,9 +347,11 @@ private void ValidateResult(void* firstOp, void* result, [CallerMemberName] stri
 
         private void ValidateResult(Single[] firstOp, Single[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (BitConverter.SingleToInt32Bits(result[0]) != BitConverter.SingleToInt32Bits(firstOp[4]))
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -352,18 +359,20 @@ private void ValidateResult(Single[] firstOp, Single[] result, [CallerMemberName
                 {
                     if ((BitConverter.SingleToInt32Bits(result[i]) != BitConverter.SingleToInt32Bits(firstOp[i + 4])))
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Avx)}.{nameof(Avx.ExtractVector128)}<Single>(Vector256<Single><9>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"  firstOp: ({string.Join(", ", firstOp)})");
                 TestLibrary.TestFramework.LogInformation($"   result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx/ExtractVector128.Single.1.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx/ExtractVector128.Single.1.cs
index d1bf7df27662..0ac4ae770c83 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Avx/ExtractVector128.Single.1.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx/ExtractVector128.Single.1.cs
@@ -319,7 +319,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -327,7 +327,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -355,9 +360,11 @@ private void ValidateResult(void* firstOp, void* result, [CallerMemberName] stri
 
         private void ValidateResult(Single[] firstOp, Single[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (BitConverter.SingleToInt32Bits(result[0]) != BitConverter.SingleToInt32Bits(firstOp[4]))
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -365,18 +372,20 @@ private void ValidateResult(Single[] firstOp, Single[] result, [CallerMemberName
                 {
                     if (BitConverter.SingleToInt32Bits(result[i]) != BitConverter.SingleToInt32Bits(firstOp[i+4]))
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Avx)}.{nameof(Avx.ExtractVector128)}<Single>(Vector256<Single><9>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"  firstOp: ({string.Join(", ", firstOp)})");
                 TestLibrary.TestFramework.LogInformation($"   result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx/ExtractVector128.UInt16.1.Store.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx/ExtractVector128.UInt16.1.Store.cs
index fcefc3be0750..5b18af83ff8d 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Avx/ExtractVector128.UInt16.1.Store.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx/ExtractVector128.UInt16.1.Store.cs
@@ -306,7 +306,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -314,7 +314,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -342,9 +347,11 @@ private void ValidateResult(void* firstOp, void* result, [CallerMemberName] stri
 
         private void ValidateResult(UInt16[] firstOp, UInt16[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (result[0] != firstOp[8])
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -352,18 +359,20 @@ private void ValidateResult(UInt16[] firstOp, UInt16[] result, [CallerMemberName
                 {
                     if ((result[i] != firstOp[i + 8]))
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Avx)}.{nameof(Avx.ExtractVector128)}<UInt16>(Vector256<UInt16><9>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"  firstOp: ({string.Join(", ", firstOp)})");
                 TestLibrary.TestFramework.LogInformation($"   result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx/ExtractVector128.UInt16.1.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx/ExtractVector128.UInt16.1.cs
index 6a7dc1f0876f..531acd327af9 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Avx/ExtractVector128.UInt16.1.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx/ExtractVector128.UInt16.1.cs
@@ -319,7 +319,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -327,7 +327,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -355,9 +360,11 @@ private void ValidateResult(void* firstOp, void* result, [CallerMemberName] stri
 
         private void ValidateResult(UInt16[] firstOp, UInt16[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (result[0] != firstOp[8])
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -365,18 +372,20 @@ private void ValidateResult(UInt16[] firstOp, UInt16[] result, [CallerMemberName
                 {
                     if (result[i] != firstOp[i+8])
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Avx)}.{nameof(Avx.ExtractVector128)}<UInt16>(Vector256<UInt16><9>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"  firstOp: ({string.Join(", ", firstOp)})");
                 TestLibrary.TestFramework.LogInformation($"   result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx/ExtractVector128.UInt32.1.Store.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx/ExtractVector128.UInt32.1.Store.cs
index d0512c51f2cd..04890df835e2 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Avx/ExtractVector128.UInt32.1.Store.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx/ExtractVector128.UInt32.1.Store.cs
@@ -306,7 +306,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -314,7 +314,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -342,9 +347,11 @@ private void ValidateResult(void* firstOp, void* result, [CallerMemberName] stri
 
         private void ValidateResult(UInt32[] firstOp, UInt32[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (result[0] != firstOp[4])
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -352,18 +359,20 @@ private void ValidateResult(UInt32[] firstOp, UInt32[] result, [CallerMemberName
                 {
                     if ((result[i] != firstOp[i + 4]))
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Avx)}.{nameof(Avx.ExtractVector128)}<UInt32>(Vector256<UInt32><9>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"  firstOp: ({string.Join(", ", firstOp)})");
                 TestLibrary.TestFramework.LogInformation($"   result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx/ExtractVector128.UInt32.1.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx/ExtractVector128.UInt32.1.cs
index 98b8d265cf74..5b7db6f611c7 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Avx/ExtractVector128.UInt32.1.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx/ExtractVector128.UInt32.1.cs
@@ -319,7 +319,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -327,7 +327,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -355,9 +360,11 @@ private void ValidateResult(void* firstOp, void* result, [CallerMemberName] stri
 
         private void ValidateResult(UInt32[] firstOp, UInt32[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (result[0] != firstOp[4])
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -365,18 +372,20 @@ private void ValidateResult(UInt32[] firstOp, UInt32[] result, [CallerMemberName
                 {
                     if (result[i] != firstOp[i+4])
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Avx)}.{nameof(Avx.ExtractVector128)}<UInt32>(Vector256<UInt32><9>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"  firstOp: ({string.Join(", ", firstOp)})");
                 TestLibrary.TestFramework.LogInformation($"   result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx/ExtractVector128.UInt64.1.Store.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx/ExtractVector128.UInt64.1.Store.cs
index da6cda26937e..c29d5c6d882b 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Avx/ExtractVector128.UInt64.1.Store.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx/ExtractVector128.UInt64.1.Store.cs
@@ -306,7 +306,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -314,7 +314,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -342,9 +347,11 @@ private void ValidateResult(void* firstOp, void* result, [CallerMemberName] stri
 
         private void ValidateResult(UInt64[] firstOp, UInt64[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (result[0] != firstOp[2])
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -352,18 +359,20 @@ private void ValidateResult(UInt64[] firstOp, UInt64[] result, [CallerMemberName
                 {
                     if ((result[i] != firstOp[i + 2]))
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Avx)}.{nameof(Avx.ExtractVector128)}<UInt64>(Vector256<UInt64><9>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"  firstOp: ({string.Join(", ", firstOp)})");
                 TestLibrary.TestFramework.LogInformation($"   result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx/ExtractVector128.UInt64.1.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx/ExtractVector128.UInt64.1.cs
index a0d30b299dcd..bdcf876f8fe4 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Avx/ExtractVector128.UInt64.1.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx/ExtractVector128.UInt64.1.cs
@@ -319,7 +319,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -327,7 +327,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -355,9 +360,11 @@ private void ValidateResult(void* firstOp, void* result, [CallerMemberName] stri
 
         private void ValidateResult(UInt64[] firstOp, UInt64[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (result[0] != firstOp[2])
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -365,18 +372,20 @@ private void ValidateResult(UInt64[] firstOp, UInt64[] result, [CallerMemberName
                 {
                     if (result[i] != firstOp[i+2])
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Avx)}.{nameof(Avx.ExtractVector128)}<UInt64>(Vector256<UInt64><9>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"  firstOp: ({string.Join(", ", firstOp)})");
                 TestLibrary.TestFramework.LogInformation($"   result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx/Floor.Double.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx/Floor.Double.cs
index 4cc14cc316c8..095efaf3e368 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Avx/Floor.Double.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx/Floor.Double.cs
@@ -312,7 +312,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -320,7 +320,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -348,9 +353,11 @@ private void ValidateResult(void* firstOp, void* result, [CallerMemberName] stri
 
         private void ValidateResult(Double[] firstOp, Double[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (BitConverter.DoubleToInt64Bits(result[0]) != BitConverter.DoubleToInt64Bits(Math.Floor(firstOp[0])))
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -358,18 +365,20 @@ private void ValidateResult(Double[] firstOp, Double[] result, [CallerMemberName
                 {
                     if (BitConverter.DoubleToInt64Bits(result[i]) != BitConverter.DoubleToInt64Bits(Math.Floor(firstOp[i])))
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Avx)}.{nameof(Avx.Floor)}<Double>(Vector256<Double>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"  firstOp: ({string.Join(", ", firstOp)})");
                 TestLibrary.TestFramework.LogInformation($"   result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx/Floor.Single.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx/Floor.Single.cs
index 7058b02fc8ec..38ce287d44eb 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Avx/Floor.Single.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx/Floor.Single.cs
@@ -312,7 +312,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -320,7 +320,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -348,9 +353,11 @@ private void ValidateResult(void* firstOp, void* result, [CallerMemberName] stri
 
         private void ValidateResult(Single[] firstOp, Single[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (BitConverter.SingleToInt32Bits(result[0]) != BitConverter.SingleToInt32Bits(MathF.Floor(firstOp[0])))
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -358,18 +365,20 @@ private void ValidateResult(Single[] firstOp, Single[] result, [CallerMemberName
                 {
                     if (BitConverter.SingleToInt32Bits(result[i]) != BitConverter.SingleToInt32Bits(MathF.Floor(firstOp[i])))
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Avx)}.{nameof(Avx.Floor)}<Single>(Vector256<Single>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"  firstOp: ({string.Join(", ", firstOp)})");
                 TestLibrary.TestFramework.LogInformation($"   result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx/InsertVector128.Byte.1.Load.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx/InsertVector128.Byte.1.Load.cs
index 67dea53d8f6b..34f6fe8ee01f 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Avx/InsertVector128.Byte.1.Load.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx/InsertVector128.Byte.1.Load.cs
@@ -343,7 +343,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -351,7 +351,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -383,9 +388,11 @@ private void ValidateResult(void* left, void* right, void* result, [CallerMember
 
         private void ValidateResult(Byte[] left, Byte[] right, Byte[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (result[0] != left[0])
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -393,19 +400,21 @@ private void ValidateResult(Byte[] left, Byte[] right, Byte[] result, [CallerMem
                 {
                     if ((i > 15 ? result[i] != right[i - 16] : result[i] != left[i]))
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Avx)}.{nameof(Avx.InsertVector128)}<Byte>(Vector256<Byte>, Vector128<Byte>.1): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx/InsertVector128.Byte.1.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx/InsertVector128.Byte.1.cs
index 1025eb913486..cde568c6afc5 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Avx/InsertVector128.Byte.1.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx/InsertVector128.Byte.1.cs
@@ -341,7 +341,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -349,7 +349,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -381,9 +386,11 @@ private void ValidateResult(void* left, void* right, void* result, [CallerMember
 
         private void ValidateResult(Byte[] left, Byte[] right, Byte[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (result[0] != left[0])
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -391,19 +398,21 @@ private void ValidateResult(Byte[] left, Byte[] right, Byte[] result, [CallerMem
                 {
                     if (result[i] != (i < 16 ? left[i] : right[i-16]))
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Avx)}.{nameof(Avx.InsertVector128)}<Byte>(Vector256<Byte>.1, Vector128<Byte>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx/InsertVector128.Double.1.Load.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx/InsertVector128.Double.1.Load.cs
index ec052c6df60d..e7e9912e8cb6 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Avx/InsertVector128.Double.1.Load.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx/InsertVector128.Double.1.Load.cs
@@ -343,7 +343,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -351,7 +351,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -383,9 +388,11 @@ private void ValidateResult(void* left, void* right, void* result, [CallerMember
 
         private void ValidateResult(Double[] left, Double[] right, Double[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (BitConverter.DoubleToInt64Bits(result[0]) != BitConverter.DoubleToInt64Bits(left[0]))
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -393,19 +400,21 @@ private void ValidateResult(Double[] left, Double[] right, Double[] result, [Cal
                 {
                     if ((i > 1 ? BitConverter.DoubleToInt64Bits(result[i]) != BitConverter.DoubleToInt64Bits(right[i - 2]) : BitConverter.DoubleToInt64Bits(result[i]) != BitConverter.DoubleToInt64Bits(left[i])))
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Avx)}.{nameof(Avx.InsertVector128)}<Double>(Vector256<Double>, Vector128<Double>.1): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx/InsertVector128.Double.1.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx/InsertVector128.Double.1.cs
index 6c2670514b98..461e84ee582b 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Avx/InsertVector128.Double.1.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx/InsertVector128.Double.1.cs
@@ -341,7 +341,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -349,7 +349,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -381,9 +386,11 @@ private void ValidateResult(void* left, void* right, void* result, [CallerMember
 
         private void ValidateResult(Double[] left, Double[] right, Double[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (BitConverter.DoubleToInt64Bits(result[0]) != BitConverter.DoubleToInt64Bits(left[0]))
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -391,19 +398,21 @@ private void ValidateResult(Double[] left, Double[] right, Double[] result, [Cal
                 {
                     if (BitConverter.DoubleToInt64Bits(result[i]) != (i < 2 ? BitConverter.DoubleToInt64Bits(left[i]) : BitConverter.DoubleToInt64Bits(right[i-2])))
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Avx)}.{nameof(Avx.InsertVector128)}<Double>(Vector256<Double>.1, Vector128<Double>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx/InsertVector128.Int16.1.Load.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx/InsertVector128.Int16.1.Load.cs
index 88848b439ca2..31b74a651940 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Avx/InsertVector128.Int16.1.Load.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx/InsertVector128.Int16.1.Load.cs
@@ -343,7 +343,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -351,7 +351,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -383,9 +388,11 @@ private void ValidateResult(void* left, void* right, void* result, [CallerMember
 
         private void ValidateResult(Int16[] left, Int16[] right, Int16[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (result[0] != left[0])
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -393,19 +400,21 @@ private void ValidateResult(Int16[] left, Int16[] right, Int16[] result, [Caller
                 {
                     if ((i > 7 ? result[i] != right[i - 8] : result[i] != left[i]))
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Avx)}.{nameof(Avx.InsertVector128)}<Int16>(Vector256<Int16>, Vector128<Int16>.1): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx/InsertVector128.Int16.1.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx/InsertVector128.Int16.1.cs
index fb6450f57b65..ed9f363570c5 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Avx/InsertVector128.Int16.1.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx/InsertVector128.Int16.1.cs
@@ -341,7 +341,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -349,7 +349,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -381,9 +386,11 @@ private void ValidateResult(void* left, void* right, void* result, [CallerMember
 
         private void ValidateResult(Int16[] left, Int16[] right, Int16[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (result[0] != left[0])
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -391,19 +398,21 @@ private void ValidateResult(Int16[] left, Int16[] right, Int16[] result, [Caller
                 {
                     if (result[i] != (i < 8 ? left[i] : right[i-8]))
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Avx)}.{nameof(Avx.InsertVector128)}<Int16>(Vector256<Int16>.1, Vector128<Int16>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx/InsertVector128.Int32.1.Load.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx/InsertVector128.Int32.1.Load.cs
index c6759647e84e..33fd52f84384 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Avx/InsertVector128.Int32.1.Load.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx/InsertVector128.Int32.1.Load.cs
@@ -343,7 +343,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -351,7 +351,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -383,9 +388,11 @@ private void ValidateResult(void* left, void* right, void* result, [CallerMember
 
         private void ValidateResult(Int32[] left, Int32[] right, Int32[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (result[0] != left[0])
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -393,19 +400,21 @@ private void ValidateResult(Int32[] left, Int32[] right, Int32[] result, [Caller
                 {
                     if ((i > 3 ? result[i] != right[i - 4] : result[i] != left[i]))
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Avx)}.{nameof(Avx.InsertVector128)}<Int32>(Vector256<Int32>, Vector128<Int32>.1): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx/InsertVector128.Int32.1.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx/InsertVector128.Int32.1.cs
index f9d58de6361a..acc04225d912 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Avx/InsertVector128.Int32.1.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx/InsertVector128.Int32.1.cs
@@ -341,7 +341,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -349,7 +349,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -381,9 +386,11 @@ private void ValidateResult(void* left, void* right, void* result, [CallerMember
 
         private void ValidateResult(Int32[] left, Int32[] right, Int32[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (result[0] != left[0])
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -391,19 +398,21 @@ private void ValidateResult(Int32[] left, Int32[] right, Int32[] result, [Caller
                 {
                     if (result[i] != (i < 4 ? left[i] : right[i-4]))
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Avx)}.{nameof(Avx.InsertVector128)}<Int32>(Vector256<Int32>.1, Vector128<Int32>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx/InsertVector128.Int64.1.Load.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx/InsertVector128.Int64.1.Load.cs
index 666279512cd3..14a7df23c57b 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Avx/InsertVector128.Int64.1.Load.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx/InsertVector128.Int64.1.Load.cs
@@ -343,7 +343,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -351,7 +351,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -383,9 +388,11 @@ private void ValidateResult(void* left, void* right, void* result, [CallerMember
 
         private void ValidateResult(Int64[] left, Int64[] right, Int64[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (result[0] != left[0])
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -393,19 +400,21 @@ private void ValidateResult(Int64[] left, Int64[] right, Int64[] result, [Caller
                 {
                     if ((i > 1 ? result[i] != right[i - 2] : result[i] != left[i]))
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Avx)}.{nameof(Avx.InsertVector128)}<Int64>(Vector256<Int64>, Vector128<Int64>.1): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx/InsertVector128.Int64.1.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx/InsertVector128.Int64.1.cs
index 6e1862f70d67..40cf18621f36 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Avx/InsertVector128.Int64.1.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx/InsertVector128.Int64.1.cs
@@ -341,7 +341,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -349,7 +349,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -381,9 +386,11 @@ private void ValidateResult(void* left, void* right, void* result, [CallerMember
 
         private void ValidateResult(Int64[] left, Int64[] right, Int64[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (result[0] != left[0])
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -391,19 +398,21 @@ private void ValidateResult(Int64[] left, Int64[] right, Int64[] result, [Caller
                 {
                     if (result[i] != (i < 2 ? left[i] : right[i-2]))
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Avx)}.{nameof(Avx.InsertVector128)}<Int64>(Vector256<Int64>.1, Vector128<Int64>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx/InsertVector128.SByte.1.Load.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx/InsertVector128.SByte.1.Load.cs
index a549fe995e36..381ff2a8691f 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Avx/InsertVector128.SByte.1.Load.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx/InsertVector128.SByte.1.Load.cs
@@ -343,7 +343,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -351,7 +351,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -383,9 +388,11 @@ private void ValidateResult(void* left, void* right, void* result, [CallerMember
 
         private void ValidateResult(SByte[] left, SByte[] right, SByte[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (result[0] != left[0])
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -393,19 +400,21 @@ private void ValidateResult(SByte[] left, SByte[] right, SByte[] result, [Caller
                 {
                     if ((i > 15 ? result[i] != right[i - 16] : result[i] != left[i]))
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Avx)}.{nameof(Avx.InsertVector128)}<SByte>(Vector256<SByte>, Vector128<SByte>.1): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx/InsertVector128.SByte.1.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx/InsertVector128.SByte.1.cs
index ac05c767460a..4acc350b443e 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Avx/InsertVector128.SByte.1.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx/InsertVector128.SByte.1.cs
@@ -341,7 +341,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -349,7 +349,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -381,9 +386,11 @@ private void ValidateResult(void* left, void* right, void* result, [CallerMember
 
         private void ValidateResult(SByte[] left, SByte[] right, SByte[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (result[0] != left[0])
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -391,19 +398,21 @@ private void ValidateResult(SByte[] left, SByte[] right, SByte[] result, [Caller
                 {
                     if (result[i] != (i < 16 ? left[i] : right[i-16]))
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Avx)}.{nameof(Avx.InsertVector128)}<SByte>(Vector256<SByte>.1, Vector128<SByte>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx/InsertVector128.Single.1.Load.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx/InsertVector128.Single.1.Load.cs
index 2b3ddf100d2a..9bd5797de8ec 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Avx/InsertVector128.Single.1.Load.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx/InsertVector128.Single.1.Load.cs
@@ -343,7 +343,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -351,7 +351,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -383,9 +388,11 @@ private void ValidateResult(void* left, void* right, void* result, [CallerMember
 
         private void ValidateResult(Single[] left, Single[] right, Single[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (BitConverter.SingleToInt32Bits(result[0]) != BitConverter.SingleToInt32Bits(left[0]))
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -393,19 +400,21 @@ private void ValidateResult(Single[] left, Single[] right, Single[] result, [Cal
                 {
                     if ((i > 3 ? BitConverter.SingleToInt32Bits(result[i]) != BitConverter.SingleToInt32Bits(right[i - 4]) : BitConverter.SingleToInt32Bits(result[i]) != BitConverter.SingleToInt32Bits(left[i])))
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Avx)}.{nameof(Avx.InsertVector128)}<Single>(Vector256<Single>, Vector128<Single>.1): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx/InsertVector128.Single.1.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx/InsertVector128.Single.1.cs
index ca2886218434..1da440fe3b18 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Avx/InsertVector128.Single.1.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx/InsertVector128.Single.1.cs
@@ -341,7 +341,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -349,7 +349,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -381,9 +386,11 @@ private void ValidateResult(void* left, void* right, void* result, [CallerMember
 
         private void ValidateResult(Single[] left, Single[] right, Single[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (BitConverter.SingleToInt32Bits(result[0]) != BitConverter.SingleToInt32Bits(left[0]))
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -391,19 +398,21 @@ private void ValidateResult(Single[] left, Single[] right, Single[] result, [Cal
                 {
                     if (BitConverter.SingleToInt32Bits(result[i]) != (i < 4 ? BitConverter.SingleToInt32Bits(left[i]) : BitConverter.SingleToInt32Bits(right[i-4])))
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Avx)}.{nameof(Avx.InsertVector128)}<Single>(Vector256<Single>.1, Vector128<Single>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx/InsertVector128.UInt16.1.Load.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx/InsertVector128.UInt16.1.Load.cs
index 00572a6fb8f0..7aa6c20a1695 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Avx/InsertVector128.UInt16.1.Load.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx/InsertVector128.UInt16.1.Load.cs
@@ -343,7 +343,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -351,7 +351,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -383,9 +388,11 @@ private void ValidateResult(void* left, void* right, void* result, [CallerMember
 
         private void ValidateResult(UInt16[] left, UInt16[] right, UInt16[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (result[0] != left[0])
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -393,19 +400,21 @@ private void ValidateResult(UInt16[] left, UInt16[] right, UInt16[] result, [Cal
                 {
                     if ((i > 7 ? result[i] != right[i - 8] : result[i] != left[i]))
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Avx)}.{nameof(Avx.InsertVector128)}<UInt16>(Vector256<UInt16>, Vector128<UInt16>.1): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx/InsertVector128.UInt16.1.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx/InsertVector128.UInt16.1.cs
index 3c93f5a7c3d6..304a5cd86a99 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Avx/InsertVector128.UInt16.1.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx/InsertVector128.UInt16.1.cs
@@ -341,7 +341,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -349,7 +349,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -381,9 +386,11 @@ private void ValidateResult(void* left, void* right, void* result, [CallerMember
 
         private void ValidateResult(UInt16[] left, UInt16[] right, UInt16[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (result[0] != left[0])
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -391,19 +398,21 @@ private void ValidateResult(UInt16[] left, UInt16[] right, UInt16[] result, [Cal
                 {
                     if (result[i] != (i < 8 ? left[i] : right[i-8]))
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Avx)}.{nameof(Avx.InsertVector128)}<UInt16>(Vector256<UInt16>.1, Vector128<UInt16>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx/InsertVector128.UInt32.1.Load.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx/InsertVector128.UInt32.1.Load.cs
index b9774e46a6d8..ba246d94631c 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Avx/InsertVector128.UInt32.1.Load.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx/InsertVector128.UInt32.1.Load.cs
@@ -343,7 +343,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -351,7 +351,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -383,9 +388,11 @@ private void ValidateResult(void* left, void* right, void* result, [CallerMember
 
         private void ValidateResult(UInt32[] left, UInt32[] right, UInt32[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (result[0] != left[0])
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -393,19 +400,21 @@ private void ValidateResult(UInt32[] left, UInt32[] right, UInt32[] result, [Cal
                 {
                     if ((i > 3 ? result[i] != right[i - 4] : result[i] != left[i]))
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Avx)}.{nameof(Avx.InsertVector128)}<UInt32>(Vector256<UInt32>, Vector128<UInt32>.1): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx/InsertVector128.UInt32.1.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx/InsertVector128.UInt32.1.cs
index a0cc5772f2be..f2c08abd7424 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Avx/InsertVector128.UInt32.1.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx/InsertVector128.UInt32.1.cs
@@ -341,7 +341,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -349,7 +349,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -381,9 +386,11 @@ private void ValidateResult(void* left, void* right, void* result, [CallerMember
 
         private void ValidateResult(UInt32[] left, UInt32[] right, UInt32[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (result[0] != left[0])
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -391,19 +398,21 @@ private void ValidateResult(UInt32[] left, UInt32[] right, UInt32[] result, [Cal
                 {
                     if (result[i] != (i < 4 ? left[i] : right[i-4]))
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Avx)}.{nameof(Avx.InsertVector128)}<UInt32>(Vector256<UInt32>.1, Vector128<UInt32>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx/InsertVector128.UInt64.1.Load.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx/InsertVector128.UInt64.1.Load.cs
index 69c32ca0c053..4d32c2e75461 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Avx/InsertVector128.UInt64.1.Load.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx/InsertVector128.UInt64.1.Load.cs
@@ -343,7 +343,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -351,7 +351,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -383,9 +388,11 @@ private void ValidateResult(void* left, void* right, void* result, [CallerMember
 
         private void ValidateResult(UInt64[] left, UInt64[] right, UInt64[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (result[0] != left[0])
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -393,19 +400,21 @@ private void ValidateResult(UInt64[] left, UInt64[] right, UInt64[] result, [Cal
                 {
                     if ((i > 1 ? result[i] != right[i - 2] : result[i] != left[i]))
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Avx)}.{nameof(Avx.InsertVector128)}<UInt64>(Vector256<UInt64>, Vector128<UInt64>.1): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx/InsertVector128.UInt64.1.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx/InsertVector128.UInt64.1.cs
index dd7765e92169..ca341612002b 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Avx/InsertVector128.UInt64.1.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx/InsertVector128.UInt64.1.cs
@@ -341,7 +341,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -349,7 +349,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -381,9 +386,11 @@ private void ValidateResult(void* left, void* right, void* result, [CallerMember
 
         private void ValidateResult(UInt64[] left, UInt64[] right, UInt64[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (result[0] != left[0])
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -391,19 +398,21 @@ private void ValidateResult(UInt64[] left, UInt64[] right, UInt64[] result, [Cal
                 {
                     if (result[i] != (i < 2 ? left[i] : right[i-2]))
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Avx)}.{nameof(Avx.InsertVector128)}<UInt64>(Vector256<UInt64>.1, Vector128<UInt64>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx/LoadVector256.Byte.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx/LoadVector256.Byte.cs
index 6de54d6326cf..29b2c25d6d27 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Avx/LoadVector256.Byte.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx/LoadVector256.Byte.cs
@@ -133,9 +133,11 @@ private void ValidateResult(void* firstOp, void* result, [CallerMemberName] stri
 
         private void ValidateResult(Byte[] firstOp, Byte[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (firstOp[0] != result[0])
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -143,18 +145,20 @@ private void ValidateResult(Byte[] firstOp, Byte[] result, [CallerMemberName] st
                 {
                     if (firstOp[i] != result[i])
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Avx)}.{nameof(Avx.LoadVector256)}<Byte>(Vector256<Byte>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"  firstOp: ({string.Join(", ", firstOp)})");
                 TestLibrary.TestFramework.LogInformation($"   result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx/LoadVector256.Double.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx/LoadVector256.Double.cs
index c9f3a0180d1c..371f6a6a6104 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Avx/LoadVector256.Double.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx/LoadVector256.Double.cs
@@ -133,9 +133,11 @@ private void ValidateResult(void* firstOp, void* result, [CallerMemberName] stri
 
         private void ValidateResult(Double[] firstOp, Double[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (BitConverter.DoubleToInt64Bits(firstOp[0]) != BitConverter.DoubleToInt64Bits(result[0]))
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -143,18 +145,20 @@ private void ValidateResult(Double[] firstOp, Double[] result, [CallerMemberName
                 {
                     if (BitConverter.DoubleToInt64Bits(firstOp[i]) != BitConverter.DoubleToInt64Bits(result[i]))
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Avx)}.{nameof(Avx.LoadVector256)}<Double>(Vector256<Double>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"  firstOp: ({string.Join(", ", firstOp)})");
                 TestLibrary.TestFramework.LogInformation($"   result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx/LoadVector256.Int16.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx/LoadVector256.Int16.cs
index 08a256e76c15..faed2628b7f9 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Avx/LoadVector256.Int16.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx/LoadVector256.Int16.cs
@@ -133,9 +133,11 @@ private void ValidateResult(void* firstOp, void* result, [CallerMemberName] stri
 
         private void ValidateResult(Int16[] firstOp, Int16[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (firstOp[0] != result[0])
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -143,18 +145,20 @@ private void ValidateResult(Int16[] firstOp, Int16[] result, [CallerMemberName]
                 {
                     if (firstOp[i] != result[i])
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Avx)}.{nameof(Avx.LoadVector256)}<Int16>(Vector256<Int16>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"  firstOp: ({string.Join(", ", firstOp)})");
                 TestLibrary.TestFramework.LogInformation($"   result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx/LoadVector256.Int32.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx/LoadVector256.Int32.cs
index b827b7f2403b..a1067398b853 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Avx/LoadVector256.Int32.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx/LoadVector256.Int32.cs
@@ -133,9 +133,11 @@ private void ValidateResult(void* firstOp, void* result, [CallerMemberName] stri
 
         private void ValidateResult(Int32[] firstOp, Int32[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (firstOp[0] != result[0])
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -143,18 +145,20 @@ private void ValidateResult(Int32[] firstOp, Int32[] result, [CallerMemberName]
                 {
                     if (firstOp[i] != result[i])
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Avx)}.{nameof(Avx.LoadVector256)}<Int32>(Vector256<Int32>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"  firstOp: ({string.Join(", ", firstOp)})");
                 TestLibrary.TestFramework.LogInformation($"   result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx/LoadVector256.Int64.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx/LoadVector256.Int64.cs
index c31bddd01efe..d062a6d0e2f7 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Avx/LoadVector256.Int64.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx/LoadVector256.Int64.cs
@@ -133,9 +133,11 @@ private void ValidateResult(void* firstOp, void* result, [CallerMemberName] stri
 
         private void ValidateResult(Int64[] firstOp, Int64[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (firstOp[0] != result[0])
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -143,18 +145,20 @@ private void ValidateResult(Int64[] firstOp, Int64[] result, [CallerMemberName]
                 {
                     if (firstOp[i] != result[i])
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Avx)}.{nameof(Avx.LoadVector256)}<Int64>(Vector256<Int64>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"  firstOp: ({string.Join(", ", firstOp)})");
                 TestLibrary.TestFramework.LogInformation($"   result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx/LoadVector256.SByte.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx/LoadVector256.SByte.cs
index ca652483e3e7..98abba33afb6 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Avx/LoadVector256.SByte.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx/LoadVector256.SByte.cs
@@ -133,9 +133,11 @@ private void ValidateResult(void* firstOp, void* result, [CallerMemberName] stri
 
         private void ValidateResult(SByte[] firstOp, SByte[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (firstOp[0] != result[0])
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -143,18 +145,20 @@ private void ValidateResult(SByte[] firstOp, SByte[] result, [CallerMemberName]
                 {
                     if (firstOp[i] != result[i])
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Avx)}.{nameof(Avx.LoadVector256)}<SByte>(Vector256<SByte>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"  firstOp: ({string.Join(", ", firstOp)})");
                 TestLibrary.TestFramework.LogInformation($"   result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx/LoadVector256.Single.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx/LoadVector256.Single.cs
index 93e458ce884c..538fcebcd13d 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Avx/LoadVector256.Single.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx/LoadVector256.Single.cs
@@ -133,9 +133,11 @@ private void ValidateResult(void* firstOp, void* result, [CallerMemberName] stri
 
         private void ValidateResult(Single[] firstOp, Single[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (BitConverter.SingleToInt32Bits(firstOp[0]) != BitConverter.SingleToInt32Bits(result[0]))
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -143,18 +145,20 @@ private void ValidateResult(Single[] firstOp, Single[] result, [CallerMemberName
                 {
                     if (BitConverter.SingleToInt32Bits(firstOp[i]) != BitConverter.SingleToInt32Bits(result[i]))
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Avx)}.{nameof(Avx.LoadVector256)}<Single>(Vector256<Single>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"  firstOp: ({string.Join(", ", firstOp)})");
                 TestLibrary.TestFramework.LogInformation($"   result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx/LoadVector256.UInt16.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx/LoadVector256.UInt16.cs
index 53c05ee32294..993ab8a849c8 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Avx/LoadVector256.UInt16.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx/LoadVector256.UInt16.cs
@@ -133,9 +133,11 @@ private void ValidateResult(void* firstOp, void* result, [CallerMemberName] stri
 
         private void ValidateResult(UInt16[] firstOp, UInt16[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (firstOp[0] != result[0])
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -143,18 +145,20 @@ private void ValidateResult(UInt16[] firstOp, UInt16[] result, [CallerMemberName
                 {
                     if (firstOp[i] != result[i])
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Avx)}.{nameof(Avx.LoadVector256)}<UInt16>(Vector256<UInt16>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"  firstOp: ({string.Join(", ", firstOp)})");
                 TestLibrary.TestFramework.LogInformation($"   result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx/LoadVector256.UInt32.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx/LoadVector256.UInt32.cs
index b236d742d095..0a45e19c8752 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Avx/LoadVector256.UInt32.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx/LoadVector256.UInt32.cs
@@ -133,9 +133,11 @@ private void ValidateResult(void* firstOp, void* result, [CallerMemberName] stri
 
         private void ValidateResult(UInt32[] firstOp, UInt32[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (firstOp[0] != result[0])
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -143,18 +145,20 @@ private void ValidateResult(UInt32[] firstOp, UInt32[] result, [CallerMemberName
                 {
                     if (firstOp[i] != result[i])
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Avx)}.{nameof(Avx.LoadVector256)}<UInt32>(Vector256<UInt32>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"  firstOp: ({string.Join(", ", firstOp)})");
                 TestLibrary.TestFramework.LogInformation($"   result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx/LoadVector256.UInt64.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx/LoadVector256.UInt64.cs
index 0c743e9023fa..c258ceaef55f 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Avx/LoadVector256.UInt64.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx/LoadVector256.UInt64.cs
@@ -133,9 +133,11 @@ private void ValidateResult(void* firstOp, void* result, [CallerMemberName] stri
 
         private void ValidateResult(UInt64[] firstOp, UInt64[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (firstOp[0] != result[0])
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -143,18 +145,20 @@ private void ValidateResult(UInt64[] firstOp, UInt64[] result, [CallerMemberName
                 {
                     if (firstOp[i] != result[i])
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Avx)}.{nameof(Avx.LoadVector256)}<UInt64>(Vector256<UInt64>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"  firstOp: ({string.Join(", ", firstOp)})");
                 TestLibrary.TestFramework.LogInformation($"   result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx/MaskLoad.Double.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx/MaskLoad.Double.cs
index a5e91584bd66..24fe0345cc1b 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Avx/MaskLoad.Double.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx/MaskLoad.Double.cs
@@ -331,7 +331,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -339,7 +339,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -371,9 +376,11 @@ private void ValidateResult(void* left, void* right, void* result, [CallerMember
 
         private void ValidateResult(Double[] left, Double[] right, Double[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (BitConverter.DoubleToInt64Bits(result[0]) != BitConverter.DoubleToInt64Bits((BitConverter.DoubleToInt64Bits(right[0]) < 0) ? left[0] : 0))
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -381,19 +388,21 @@ private void ValidateResult(Double[] left, Double[] right, Double[] result, [Cal
                 {
                     if (BitConverter.DoubleToInt64Bits(result[i]) != BitConverter.DoubleToInt64Bits((BitConverter.DoubleToInt64Bits(right[i]) < 0) ? left[i] : 0))
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Avx)}.{nameof(Avx.MaskLoad)}<Double>(Double*, Vector256<Double>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx/MaskLoad.Single.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx/MaskLoad.Single.cs
index 4d96d682de03..77a4d699fc17 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Avx/MaskLoad.Single.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx/MaskLoad.Single.cs
@@ -331,7 +331,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -339,7 +339,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -371,9 +376,11 @@ private void ValidateResult(void* left, void* right, void* result, [CallerMember
 
         private void ValidateResult(Single[] left, Single[] right, Single[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (BitConverter.SingleToInt32Bits(result[0]) != BitConverter.SingleToInt32Bits((BitConverter.SingleToInt32Bits(right[0]) < 0) ? left[0] : 0))
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -381,19 +388,21 @@ private void ValidateResult(Single[] left, Single[] right, Single[] result, [Cal
                 {
                     if (BitConverter.SingleToInt32Bits(result[i]) != BitConverter.SingleToInt32Bits((BitConverter.SingleToInt32Bits(right[i]) < 0) ? left[i] : 0))
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Avx)}.{nameof(Avx.MaskLoad)}<Single>(Single*, Vector256<Single>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx/MaskStore.Double.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx/MaskStore.Double.cs
index 6b505d11cef5..677390e73bab 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Avx/MaskStore.Double.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx/MaskStore.Double.cs
@@ -326,7 +326,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -334,7 +334,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -366,9 +371,11 @@ private void ValidateResult(void* left, void* right, void* result, [CallerMember
 
         private void ValidateResult(Double[] left, Double[] right, Double[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (BitConverter.DoubleToInt64Bits(result[0]) != BitConverter.DoubleToInt64Bits((BitConverter.DoubleToInt64Bits(left[0]) < 0) ? right[0] : BitConverter.DoubleToInt64Bits(result[0])))
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -376,19 +383,21 @@ private void ValidateResult(Double[] left, Double[] right, Double[] result, [Cal
                 {
                     if (BitConverter.DoubleToInt64Bits(result[i]) != BitConverter.DoubleToInt64Bits((BitConverter.DoubleToInt64Bits(left[i]) < 0) ? right[i] : BitConverter.DoubleToInt64Bits(result[i])))
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Avx)}.{nameof(Avx.MaskStore)}<Double>(Vector256<Double>, Vector256<Double>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx/MaskStore.Single.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx/MaskStore.Single.cs
index 67de485806b1..f4a0c42ccd03 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Avx/MaskStore.Single.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx/MaskStore.Single.cs
@@ -326,7 +326,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -334,7 +334,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -366,9 +371,11 @@ private void ValidateResult(void* left, void* right, void* result, [CallerMember
 
         private void ValidateResult(Single[] left, Single[] right, Single[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (BitConverter.SingleToInt32Bits(result[0]) != BitConverter.SingleToInt32Bits((BitConverter.SingleToInt32Bits(left[0]) < 0) ? right[0] : BitConverter.SingleToInt32Bits(result[0])))
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -376,19 +383,21 @@ private void ValidateResult(Single[] left, Single[] right, Single[] result, [Cal
                 {
                     if (BitConverter.SingleToInt32Bits(result[i]) != BitConverter.SingleToInt32Bits((BitConverter.SingleToInt32Bits(left[i]) < 0) ? right[i] : BitConverter.SingleToInt32Bits(result[i])))
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Avx)}.{nameof(Avx.MaskStore)}<Single>(Vector256<Single>, Vector256<Single>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx/Max.Double.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx/Max.Double.cs
index ce8141a60f6e..18c3c45d87b4 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Avx/Max.Double.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx/Max.Double.cs
@@ -334,7 +334,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -342,7 +342,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -374,9 +379,11 @@ private void ValidateResult(void* left, void* right, void* result, [CallerMember
 
         private void ValidateResult(Double[] left, Double[] right, Double[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (BitConverter.DoubleToInt64Bits(Math.Max(left[0], right[0])) != BitConverter.DoubleToInt64Bits(result[0]))
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -384,19 +391,21 @@ private void ValidateResult(Double[] left, Double[] right, Double[] result, [Cal
                 {
                     if (BitConverter.DoubleToInt64Bits(Math.Max(left[i], right[i])) != BitConverter.DoubleToInt64Bits(result[i]))
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Avx)}.{nameof(Avx.Max)}<Double>(Vector256<Double>, Vector256<Double>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx/Max.Single.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx/Max.Single.cs
index f9c33f3b72ae..b116b4f2c451 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Avx/Max.Single.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx/Max.Single.cs
@@ -334,7 +334,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -342,7 +342,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -374,9 +379,11 @@ private void ValidateResult(void* left, void* right, void* result, [CallerMember
 
         private void ValidateResult(Single[] left, Single[] right, Single[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (BitConverter.SingleToInt32Bits(MathF.Max(left[0], right[0])) != BitConverter.SingleToInt32Bits(result[0]))
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -384,19 +391,21 @@ private void ValidateResult(Single[] left, Single[] right, Single[] result, [Cal
                 {
                     if (BitConverter.SingleToInt32Bits(MathF.Max(left[i], right[i])) != BitConverter.SingleToInt32Bits(result[i]))
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Avx)}.{nameof(Avx.Max)}<Single>(Vector256<Single>, Vector256<Single>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx/Min.Double.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx/Min.Double.cs
index dd0213de90dd..ac9249e5d2e8 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Avx/Min.Double.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx/Min.Double.cs
@@ -334,7 +334,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -342,7 +342,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -374,9 +379,11 @@ private void ValidateResult(void* left, void* right, void* result, [CallerMember
 
         private void ValidateResult(Double[] left, Double[] right, Double[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (BitConverter.DoubleToInt64Bits(Math.Min(left[0], right[0])) != BitConverter.DoubleToInt64Bits(result[0]))
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -384,19 +391,21 @@ private void ValidateResult(Double[] left, Double[] right, Double[] result, [Cal
                 {
                     if (BitConverter.DoubleToInt64Bits(Math.Min(left[i], right[i])) != BitConverter.DoubleToInt64Bits(result[i]))
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Avx)}.{nameof(Avx.Min)}<Double>(Vector256<Double>, Vector256<Double>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx/Min.Single.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx/Min.Single.cs
index cac123fe68ef..6ffb4b326acc 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Avx/Min.Single.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx/Min.Single.cs
@@ -334,7 +334,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -342,7 +342,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -374,9 +379,11 @@ private void ValidateResult(void* left, void* right, void* result, [CallerMember
 
         private void ValidateResult(Single[] left, Single[] right, Single[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (BitConverter.SingleToInt32Bits(MathF.Min(left[0], right[0])) != BitConverter.SingleToInt32Bits(result[0]))
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -384,19 +391,21 @@ private void ValidateResult(Single[] left, Single[] right, Single[] result, [Cal
                 {
                     if (BitConverter.SingleToInt32Bits(MathF.Min(left[i], right[i])) != BitConverter.SingleToInt32Bits(result[i]))
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Avx)}.{nameof(Avx.Min)}<Single>(Vector256<Single>, Vector256<Single>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx/Multiply.Double.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx/Multiply.Double.cs
index d79b8172e79b..5a6968f33c84 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Avx/Multiply.Double.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx/Multiply.Double.cs
@@ -334,7 +334,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -342,7 +342,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -374,9 +379,11 @@ private void ValidateResult(void* left, void* right, void* result, [CallerMember
 
         private void ValidateResult(Double[] left, Double[] right, Double[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (BitConverter.DoubleToInt64Bits(left[0] * right[0]) != BitConverter.DoubleToInt64Bits(result[0]))
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -384,19 +391,21 @@ private void ValidateResult(Double[] left, Double[] right, Double[] result, [Cal
                 {
                     if (BitConverter.DoubleToInt64Bits(left[i] * right[i]) != BitConverter.DoubleToInt64Bits(result[i]))
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Avx)}.{nameof(Avx.Multiply)}<Double>(Vector256<Double>, Vector256<Double>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx/Multiply.Single.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx/Multiply.Single.cs
index 7ce024fe5996..84b5004a86a0 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Avx/Multiply.Single.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx/Multiply.Single.cs
@@ -334,7 +334,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -342,7 +342,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -374,9 +379,11 @@ private void ValidateResult(void* left, void* right, void* result, [CallerMember
 
         private void ValidateResult(Single[] left, Single[] right, Single[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (BitConverter.SingleToInt32Bits(left[0] * right[0]) != BitConverter.SingleToInt32Bits(result[0]))
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -384,19 +391,21 @@ private void ValidateResult(Single[] left, Single[] right, Single[] result, [Cal
                 {
                     if (BitConverter.SingleToInt32Bits(left[i] * right[i]) != BitConverter.SingleToInt32Bits(result[i]))
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Avx)}.{nameof(Avx.Multiply)}<Single>(Vector256<Single>, Vector256<Single>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx/Or.Double.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx/Or.Double.cs
index 82d948412e38..1db8bec49328 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Avx/Or.Double.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx/Or.Double.cs
@@ -334,7 +334,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -342,7 +342,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -374,9 +379,11 @@ private void ValidateResult(void* left, void* right, void* result, [CallerMember
 
         private void ValidateResult(Double[] left, Double[] right, Double[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if ((BitConverter.DoubleToInt64Bits(left[0]) | BitConverter.DoubleToInt64Bits(right[0])) != BitConverter.DoubleToInt64Bits(result[0]))
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -384,19 +391,21 @@ private void ValidateResult(Double[] left, Double[] right, Double[] result, [Cal
                 {
                     if ((BitConverter.DoubleToInt64Bits(left[i]) | BitConverter.DoubleToInt64Bits(right[i])) != BitConverter.DoubleToInt64Bits(result[i]))
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Avx)}.{nameof(Avx.Or)}<Double>(Vector256<Double>, Vector256<Double>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx/Or.Single.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx/Or.Single.cs
index 50da1a6b03cb..7d0155047833 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Avx/Or.Single.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx/Or.Single.cs
@@ -334,7 +334,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -342,7 +342,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -374,9 +379,11 @@ private void ValidateResult(void* left, void* right, void* result, [CallerMember
 
         private void ValidateResult(Single[] left, Single[] right, Single[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if ((BitConverter.SingleToInt32Bits(left[0]) | BitConverter.SingleToInt32Bits(right[0])) != BitConverter.SingleToInt32Bits(result[0]))
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -384,19 +391,21 @@ private void ValidateResult(Single[] left, Single[] right, Single[] result, [Cal
                 {
                     if ((BitConverter.SingleToInt32Bits(left[i]) | BitConverter.SingleToInt32Bits(right[i])) != BitConverter.SingleToInt32Bits(result[i]))
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Avx)}.{nameof(Avx.Or)}<Single>(Vector256<Single>, Vector256<Single>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx/Permute.Double.1.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx/Permute.Double.1.cs
index f295c95c62e9..664cfe4c34f2 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Avx/Permute.Double.1.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx/Permute.Double.1.cs
@@ -319,7 +319,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -327,7 +327,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -355,9 +360,11 @@ private void ValidateResult(void* firstOp, void* result, [CallerMemberName] stri
 
         private void ValidateResult(Double[] firstOp, Double[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (BitConverter.DoubleToInt64Bits(result[0]) != BitConverter.DoubleToInt64Bits(firstOp[1]))
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -365,18 +372,20 @@ private void ValidateResult(Double[] firstOp, Double[] result, [CallerMemberName
                 {
                     if (BitConverter.DoubleToInt64Bits(result[2]) != BitConverter.DoubleToInt64Bits(firstOp[2]) || BitConverter.DoubleToInt64Bits(result[2]) != BitConverter.DoubleToInt64Bits(firstOp[2]))
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Avx)}.{nameof(Avx.Permute)}<Double>(Vector256<Double><9>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"  firstOp: ({string.Join(", ", firstOp)})");
                 TestLibrary.TestFramework.LogInformation($"   result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx/Permute.Double.2.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx/Permute.Double.2.cs
index c929189475ed..65439aae26a3 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Avx/Permute.Double.2.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx/Permute.Double.2.cs
@@ -319,7 +319,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -327,7 +327,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -355,9 +360,11 @@ private void ValidateResult(void* firstOp, void* result, [CallerMemberName] stri
 
         private void ValidateResult(Double[] firstOp, Double[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (BitConverter.DoubleToInt64Bits(result[0]) != BitConverter.DoubleToInt64Bits(firstOp[0]))
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -365,18 +372,20 @@ private void ValidateResult(Double[] firstOp, Double[] result, [CallerMemberName
                 {
                     if (BitConverter.DoubleToInt64Bits(result[1]) != BitConverter.DoubleToInt64Bits(firstOp[1]))
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Avx)}.{nameof(Avx.Permute)}<Double>(Vector128<Double><9>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"  firstOp: ({string.Join(", ", firstOp)})");
                 TestLibrary.TestFramework.LogInformation($"   result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx/Permute.Single.1.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx/Permute.Single.1.cs
index 2d8c6c7415da..a5e99321ab80 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Avx/Permute.Single.1.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx/Permute.Single.1.cs
@@ -319,7 +319,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -327,7 +327,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -355,9 +360,11 @@ private void ValidateResult(void* firstOp, void* result, [CallerMemberName] stri
 
         private void ValidateResult(Single[] firstOp, Single[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (BitConverter.SingleToInt32Bits(result[0]) != BitConverter.SingleToInt32Bits(firstOp[1]))
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -365,18 +372,20 @@ private void ValidateResult(Single[] firstOp, Single[] result, [CallerMemberName
                 {
                     if (BitConverter.SingleToInt32Bits(result[4]) != BitConverter.SingleToInt32Bits(firstOp[5]))
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Avx)}.{nameof(Avx.Permute)}<Single>(Vector256<Single><9>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"  firstOp: ({string.Join(", ", firstOp)})");
                 TestLibrary.TestFramework.LogInformation($"   result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx/Permute.Single.2.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx/Permute.Single.2.cs
index 58ad78793f80..1bf34509e85e 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Avx/Permute.Single.2.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx/Permute.Single.2.cs
@@ -319,7 +319,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -327,7 +327,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -355,9 +360,11 @@ private void ValidateResult(void* firstOp, void* result, [CallerMemberName] stri
 
         private void ValidateResult(Single[] firstOp, Single[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (BitConverter.SingleToInt32Bits(result[0]) != BitConverter.SingleToInt32Bits(firstOp[2]))
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -365,18 +372,20 @@ private void ValidateResult(Single[] firstOp, Single[] result, [CallerMemberName
                 {
                     if (BitConverter.SingleToInt32Bits(result[1]) != BitConverter.SingleToInt32Bits(firstOp[0]) || BitConverter.SingleToInt32Bits(result[2]) != BitConverter.SingleToInt32Bits(firstOp[0]))
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Avx)}.{nameof(Avx.Permute)}<Single>(Vector128<Single><9>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"  firstOp: ({string.Join(", ", firstOp)})");
                 TestLibrary.TestFramework.LogInformation($"   result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx/Permute2x128.Byte.2.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx/Permute2x128.Byte.2.cs
index 30deef4d72c1..3c51a3885a18 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Avx/Permute2x128.Byte.2.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx/Permute2x128.Byte.2.cs
@@ -341,7 +341,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -349,7 +349,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -381,9 +386,11 @@ private void ValidateResult(void* left, void* right, void* result, [CallerMember
 
         private void ValidateResult(Byte[] left, Byte[] right, Byte[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (result[0] != right[0])
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -391,19 +398,21 @@ private void ValidateResult(Byte[] left, Byte[] right, Byte[] result, [CallerMem
                 {
                     if (result[i] != (i < 16 ? right[i] : left[i-16]))
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Avx)}.{nameof(Avx.Permute2x128)}<Byte>(Vector256<Byte>.2, Vector256<Byte>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx/Permute2x128.Double.2.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx/Permute2x128.Double.2.cs
index c7e1f8179092..e02bd9049dcc 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Avx/Permute2x128.Double.2.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx/Permute2x128.Double.2.cs
@@ -341,7 +341,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -349,7 +349,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -381,9 +386,11 @@ private void ValidateResult(void* left, void* right, void* result, [CallerMember
 
         private void ValidateResult(Double[] left, Double[] right, Double[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (BitConverter.DoubleToInt64Bits(result[0]) != BitConverter.DoubleToInt64Bits(right[0]))
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -391,19 +398,21 @@ private void ValidateResult(Double[] left, Double[] right, Double[] result, [Cal
                 {
                     if (BitConverter.DoubleToInt64Bits(result[i]) != (i < 2 ? BitConverter.DoubleToInt64Bits(right[i]) : BitConverter.DoubleToInt64Bits(left[i-2])))
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Avx)}.{nameof(Avx.Permute2x128)}<Double>(Vector256<Double>.2, Vector256<Double>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx/Permute2x128.Int16.2.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx/Permute2x128.Int16.2.cs
index 8bf451bddcf0..ac0ebe31537d 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Avx/Permute2x128.Int16.2.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx/Permute2x128.Int16.2.cs
@@ -341,7 +341,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -349,7 +349,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -381,9 +386,11 @@ private void ValidateResult(void* left, void* right, void* result, [CallerMember
 
         private void ValidateResult(Int16[] left, Int16[] right, Int16[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (result[0] != right[0])
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -391,19 +398,21 @@ private void ValidateResult(Int16[] left, Int16[] right, Int16[] result, [Caller
                 {
                     if (result[i] != (i < 8 ? right[i] : left[i-8]))
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Avx)}.{nameof(Avx.Permute2x128)}<Int16>(Vector256<Int16>.2, Vector256<Int16>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx/Permute2x128.Int32.2.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx/Permute2x128.Int32.2.cs
index a0224369864f..4d2e49b8b136 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Avx/Permute2x128.Int32.2.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx/Permute2x128.Int32.2.cs
@@ -341,7 +341,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -349,7 +349,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -381,9 +386,11 @@ private void ValidateResult(void* left, void* right, void* result, [CallerMember
 
         private void ValidateResult(Int32[] left, Int32[] right, Int32[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (result[0] != right[0])
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -391,19 +398,21 @@ private void ValidateResult(Int32[] left, Int32[] right, Int32[] result, [Caller
                 {
                     if (result[i] != (i < 4 ? right[i] : left[i-4]))
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Avx)}.{nameof(Avx.Permute2x128)}<Int32>(Vector256<Int32>.2, Vector256<Int32>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx/Permute2x128.Int64.2.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx/Permute2x128.Int64.2.cs
index 13c0a398457d..006f2eef1c1f 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Avx/Permute2x128.Int64.2.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx/Permute2x128.Int64.2.cs
@@ -341,7 +341,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -349,7 +349,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -381,9 +386,11 @@ private void ValidateResult(void* left, void* right, void* result, [CallerMember
 
         private void ValidateResult(Int64[] left, Int64[] right, Int64[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (result[0] != right[0])
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -391,19 +398,21 @@ private void ValidateResult(Int64[] left, Int64[] right, Int64[] result, [Caller
                 {
                     if (result[i] != (i < 2 ? right[i] : left[i-2]))
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Avx)}.{nameof(Avx.Permute2x128)}<Int64>(Vector256<Int64>.2, Vector256<Int64>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx/Permute2x128.SByte.2.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx/Permute2x128.SByte.2.cs
index 3f864733d465..79fa69ec3b1a 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Avx/Permute2x128.SByte.2.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx/Permute2x128.SByte.2.cs
@@ -341,7 +341,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -349,7 +349,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -381,9 +386,11 @@ private void ValidateResult(void* left, void* right, void* result, [CallerMember
 
         private void ValidateResult(SByte[] left, SByte[] right, SByte[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (result[0] != right[0])
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -391,19 +398,21 @@ private void ValidateResult(SByte[] left, SByte[] right, SByte[] result, [Caller
                 {
                     if (result[i] != (i < 16 ? right[i] : left[i-16]))
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Avx)}.{nameof(Avx.Permute2x128)}<SByte>(Vector256<SByte>.2, Vector256<SByte>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx/Permute2x128.Single.2.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx/Permute2x128.Single.2.cs
index cf520265be63..9784fc133820 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Avx/Permute2x128.Single.2.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx/Permute2x128.Single.2.cs
@@ -341,7 +341,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -349,7 +349,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -381,9 +386,11 @@ private void ValidateResult(void* left, void* right, void* result, [CallerMember
 
         private void ValidateResult(Single[] left, Single[] right, Single[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (BitConverter.SingleToInt32Bits(result[0]) != BitConverter.SingleToInt32Bits(right[0]))
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -391,19 +398,21 @@ private void ValidateResult(Single[] left, Single[] right, Single[] result, [Cal
                 {
                     if (BitConverter.SingleToInt32Bits(result[i]) != (i < 4 ? BitConverter.SingleToInt32Bits(right[i]) : BitConverter.SingleToInt32Bits(left[i-4])))
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Avx)}.{nameof(Avx.Permute2x128)}<Single>(Vector256<Single>.2, Vector256<Single>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx/Permute2x128.UInt16.2.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx/Permute2x128.UInt16.2.cs
index 832257e1835c..ca5aa7eb4d87 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Avx/Permute2x128.UInt16.2.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx/Permute2x128.UInt16.2.cs
@@ -341,7 +341,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -349,7 +349,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -381,9 +386,11 @@ private void ValidateResult(void* left, void* right, void* result, [CallerMember
 
         private void ValidateResult(UInt16[] left, UInt16[] right, UInt16[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (result[0] != right[0])
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -391,19 +398,21 @@ private void ValidateResult(UInt16[] left, UInt16[] right, UInt16[] result, [Cal
                 {
                     if (result[i] != (i < 8 ? right[i] : left[i-8]))
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Avx)}.{nameof(Avx.Permute2x128)}<UInt16>(Vector256<UInt16>.2, Vector256<UInt16>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx/Permute2x128.UInt32.2.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx/Permute2x128.UInt32.2.cs
index 84e9d03c6756..46160a08a0e9 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Avx/Permute2x128.UInt32.2.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx/Permute2x128.UInt32.2.cs
@@ -341,7 +341,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -349,7 +349,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -381,9 +386,11 @@ private void ValidateResult(void* left, void* right, void* result, [CallerMember
 
         private void ValidateResult(UInt32[] left, UInt32[] right, UInt32[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (result[0] != right[0])
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -391,19 +398,21 @@ private void ValidateResult(UInt32[] left, UInt32[] right, UInt32[] result, [Cal
                 {
                     if (result[i] != (i < 4 ? right[i] : left[i-4]))
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Avx)}.{nameof(Avx.Permute2x128)}<UInt32>(Vector256<UInt32>.2, Vector256<UInt32>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx/Permute2x128.UInt64.2.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx/Permute2x128.UInt64.2.cs
index 79c8f8b5d1f9..e7384bba8cd0 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Avx/Permute2x128.UInt64.2.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx/Permute2x128.UInt64.2.cs
@@ -341,7 +341,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -349,7 +349,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -381,9 +386,11 @@ private void ValidateResult(void* left, void* right, void* result, [CallerMember
 
         private void ValidateResult(UInt64[] left, UInt64[] right, UInt64[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (result[0] != right[0])
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -391,19 +398,21 @@ private void ValidateResult(UInt64[] left, UInt64[] right, UInt64[] result, [Cal
                 {
                     if (result[i] != (i < 2 ? right[i] : left[i-2]))
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Avx)}.{nameof(Avx.Permute2x128)}<UInt64>(Vector256<UInt64>.2, Vector256<UInt64>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx/RoundCurrentDirection.Double.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx/RoundCurrentDirection.Double.cs
index c99b3398e938..37b8312194ba 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Avx/RoundCurrentDirection.Double.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx/RoundCurrentDirection.Double.cs
@@ -312,7 +312,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -320,7 +320,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -348,9 +353,11 @@ private void ValidateResult(void* firstOp, void* result, [CallerMemberName] stri
 
         private void ValidateResult(Double[] firstOp, Double[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (BitConverter.DoubleToInt64Bits(result[0]) != BitConverter.DoubleToInt64Bits(Math.Round(firstOp[0])))
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -358,18 +365,20 @@ private void ValidateResult(Double[] firstOp, Double[] result, [CallerMemberName
                 {
                     if (BitConverter.DoubleToInt64Bits(result[i]) != BitConverter.DoubleToInt64Bits(Math.Round(firstOp[i])))
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Avx)}.{nameof(Avx.RoundCurrentDirection)}<Double>(Vector256<Double>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"  firstOp: ({string.Join(", ", firstOp)})");
                 TestLibrary.TestFramework.LogInformation($"   result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx/RoundCurrentDirection.Single.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx/RoundCurrentDirection.Single.cs
index df5232ff63e8..8aa0e7ddf11f 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Avx/RoundCurrentDirection.Single.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx/RoundCurrentDirection.Single.cs
@@ -312,7 +312,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -320,7 +320,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -348,9 +353,11 @@ private void ValidateResult(void* firstOp, void* result, [CallerMemberName] stri
 
         private void ValidateResult(Single[] firstOp, Single[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (BitConverter.SingleToInt32Bits(result[0]) != BitConverter.SingleToInt32Bits(MathF.Round(firstOp[0])))
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -358,18 +365,20 @@ private void ValidateResult(Single[] firstOp, Single[] result, [CallerMemberName
                 {
                     if (BitConverter.SingleToInt32Bits(result[i]) != BitConverter.SingleToInt32Bits(MathF.Round(firstOp[i])))
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Avx)}.{nameof(Avx.RoundCurrentDirection)}<Single>(Vector256<Single>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"  firstOp: ({string.Join(", ", firstOp)})");
                 TestLibrary.TestFramework.LogInformation($"   result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx/RoundToNearestInteger.Double.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx/RoundToNearestInteger.Double.cs
index 63bd5e626266..3dbc7ea610c8 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Avx/RoundToNearestInteger.Double.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx/RoundToNearestInteger.Double.cs
@@ -312,7 +312,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -320,7 +320,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -348,9 +353,11 @@ private void ValidateResult(void* firstOp, void* result, [CallerMemberName] stri
 
         private void ValidateResult(Double[] firstOp, Double[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (BitConverter.DoubleToInt64Bits(result[0]) != BitConverter.DoubleToInt64Bits(Math.Round(firstOp[0], MidpointRounding.AwayFromZero)))
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -358,18 +365,20 @@ private void ValidateResult(Double[] firstOp, Double[] result, [CallerMemberName
                 {
                     if (BitConverter.DoubleToInt64Bits(result[i]) != BitConverter.DoubleToInt64Bits(Math.Round(firstOp[i], MidpointRounding.AwayFromZero)))
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Avx)}.{nameof(Avx.RoundToNearestInteger)}<Double>(Vector256<Double>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"  firstOp: ({string.Join(", ", firstOp)})");
                 TestLibrary.TestFramework.LogInformation($"   result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx/RoundToNearestInteger.Single.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx/RoundToNearestInteger.Single.cs
index 1f7b2f495656..ec79ee30fa96 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Avx/RoundToNearestInteger.Single.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx/RoundToNearestInteger.Single.cs
@@ -312,7 +312,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -320,7 +320,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -348,9 +353,11 @@ private void ValidateResult(void* firstOp, void* result, [CallerMemberName] stri
 
         private void ValidateResult(Single[] firstOp, Single[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (BitConverter.SingleToInt32Bits(result[0]) != BitConverter.SingleToInt32Bits(MathF.Round(firstOp[0], MidpointRounding.AwayFromZero)))
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -358,18 +365,20 @@ private void ValidateResult(Single[] firstOp, Single[] result, [CallerMemberName
                 {
                     if (BitConverter.SingleToInt32Bits(result[i]) != BitConverter.SingleToInt32Bits(MathF.Round(firstOp[i], MidpointRounding.AwayFromZero)))
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Avx)}.{nameof(Avx.RoundToNearestInteger)}<Single>(Vector256<Single>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"  firstOp: ({string.Join(", ", firstOp)})");
                 TestLibrary.TestFramework.LogInformation($"   result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx/RoundToNegativeInfinity.Double.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx/RoundToNegativeInfinity.Double.cs
index 75c8437b9155..7d339e0863c1 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Avx/RoundToNegativeInfinity.Double.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx/RoundToNegativeInfinity.Double.cs
@@ -312,7 +312,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -320,7 +320,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -348,9 +353,11 @@ private void ValidateResult(void* firstOp, void* result, [CallerMemberName] stri
 
         private void ValidateResult(Double[] firstOp, Double[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (BitConverter.DoubleToInt64Bits(result[0]) != BitConverter.DoubleToInt64Bits(Math.Floor(firstOp[0])))
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -358,18 +365,20 @@ private void ValidateResult(Double[] firstOp, Double[] result, [CallerMemberName
                 {
                     if (BitConverter.DoubleToInt64Bits(result[i]) != BitConverter.DoubleToInt64Bits(Math.Floor(firstOp[i])))
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Avx)}.{nameof(Avx.RoundToNegativeInfinity)}<Double>(Vector256<Double>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"  firstOp: ({string.Join(", ", firstOp)})");
                 TestLibrary.TestFramework.LogInformation($"   result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx/RoundToNegativeInfinity.Single.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx/RoundToNegativeInfinity.Single.cs
index 5fcb3e99e3fc..15a370f2baf6 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Avx/RoundToNegativeInfinity.Single.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx/RoundToNegativeInfinity.Single.cs
@@ -312,7 +312,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -320,7 +320,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -348,9 +353,11 @@ private void ValidateResult(void* firstOp, void* result, [CallerMemberName] stri
 
         private void ValidateResult(Single[] firstOp, Single[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (BitConverter.SingleToInt32Bits(result[0]) != BitConverter.SingleToInt32Bits(MathF.Floor(firstOp[0])))
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -358,18 +365,20 @@ private void ValidateResult(Single[] firstOp, Single[] result, [CallerMemberName
                 {
                     if (BitConverter.SingleToInt32Bits(result[i]) != BitConverter.SingleToInt32Bits(MathF.Floor(firstOp[i])))
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Avx)}.{nameof(Avx.RoundToNegativeInfinity)}<Single>(Vector256<Single>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"  firstOp: ({string.Join(", ", firstOp)})");
                 TestLibrary.TestFramework.LogInformation($"   result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx/RoundToPositiveInfinity.Double.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx/RoundToPositiveInfinity.Double.cs
index ec5c36022f7b..13cccda13f40 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Avx/RoundToPositiveInfinity.Double.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx/RoundToPositiveInfinity.Double.cs
@@ -312,7 +312,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -320,7 +320,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -348,9 +353,11 @@ private void ValidateResult(void* firstOp, void* result, [CallerMemberName] stri
 
         private void ValidateResult(Double[] firstOp, Double[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (BitConverter.DoubleToInt64Bits(result[0]) != BitConverter.DoubleToInt64Bits(Math.Ceiling(firstOp[0])))
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -358,18 +365,20 @@ private void ValidateResult(Double[] firstOp, Double[] result, [CallerMemberName
                 {
                     if (BitConverter.DoubleToInt64Bits(result[i]) != BitConverter.DoubleToInt64Bits(Math.Ceiling(firstOp[i])))
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Avx)}.{nameof(Avx.RoundToPositiveInfinity)}<Double>(Vector256<Double>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"  firstOp: ({string.Join(", ", firstOp)})");
                 TestLibrary.TestFramework.LogInformation($"   result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx/RoundToPositiveInfinity.Single.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx/RoundToPositiveInfinity.Single.cs
index a4186a07144a..be55a6e5f05b 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Avx/RoundToPositiveInfinity.Single.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx/RoundToPositiveInfinity.Single.cs
@@ -312,7 +312,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -320,7 +320,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -348,9 +353,11 @@ private void ValidateResult(void* firstOp, void* result, [CallerMemberName] stri
 
         private void ValidateResult(Single[] firstOp, Single[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (BitConverter.SingleToInt32Bits(result[0]) != BitConverter.SingleToInt32Bits(MathF.Ceiling(firstOp[0])))
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -358,18 +365,20 @@ private void ValidateResult(Single[] firstOp, Single[] result, [CallerMemberName
                 {
                     if (BitConverter.SingleToInt32Bits(result[i]) != BitConverter.SingleToInt32Bits(MathF.Ceiling(firstOp[i])))
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Avx)}.{nameof(Avx.RoundToPositiveInfinity)}<Single>(Vector256<Single>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"  firstOp: ({string.Join(", ", firstOp)})");
                 TestLibrary.TestFramework.LogInformation($"   result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx/RoundToZero.Double.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx/RoundToZero.Double.cs
index e9d62b7a561e..3ce5037228e8 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Avx/RoundToZero.Double.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx/RoundToZero.Double.cs
@@ -312,7 +312,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -320,7 +320,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -348,9 +353,11 @@ private void ValidateResult(void* firstOp, void* result, [CallerMemberName] stri
 
         private void ValidateResult(Double[] firstOp, Double[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (BitConverter.DoubleToInt64Bits(result[0]) != BitConverter.DoubleToInt64Bits((firstOp[0] > 0) ? Math.Floor(firstOp[0]) : Math.Ceiling(firstOp[0])))
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -358,18 +365,20 @@ private void ValidateResult(Double[] firstOp, Double[] result, [CallerMemberName
                 {
                     if (BitConverter.DoubleToInt64Bits(result[i]) != BitConverter.DoubleToInt64Bits((firstOp[i] > 0) ? Math.Floor(firstOp[i]) : Math.Ceiling(firstOp[i])))
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Avx)}.{nameof(Avx.RoundToZero)}<Double>(Vector256<Double>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"  firstOp: ({string.Join(", ", firstOp)})");
                 TestLibrary.TestFramework.LogInformation($"   result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx/RoundToZero.Single.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx/RoundToZero.Single.cs
index ad8b5f24776c..5010c061094c 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Avx/RoundToZero.Single.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx/RoundToZero.Single.cs
@@ -312,7 +312,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -320,7 +320,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -348,9 +353,11 @@ private void ValidateResult(void* firstOp, void* result, [CallerMemberName] stri
 
         private void ValidateResult(Single[] firstOp, Single[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (BitConverter.SingleToInt32Bits(result[0]) != BitConverter.SingleToInt32Bits((firstOp[0] > 0) ? MathF.Floor(firstOp[0]) : MathF.Ceiling(firstOp[0])))
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -358,18 +365,20 @@ private void ValidateResult(Single[] firstOp, Single[] result, [CallerMemberName
                 {
                     if (BitConverter.SingleToInt32Bits(result[i]) != BitConverter.SingleToInt32Bits((firstOp[i] > 0) ? MathF.Floor(firstOp[i]) : MathF.Ceiling(firstOp[i])))
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Avx)}.{nameof(Avx.RoundToZero)}<Single>(Vector256<Single>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"  firstOp: ({string.Join(", ", firstOp)})");
                 TestLibrary.TestFramework.LogInformation($"   result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx/Shuffle.Double.1.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx/Shuffle.Double.1.cs
index 08094a7dd809..8c879b064c4f 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Avx/Shuffle.Double.1.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx/Shuffle.Double.1.cs
@@ -341,7 +341,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -349,7 +349,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -381,9 +386,11 @@ private void ValidateResult(void* left, void* right, void* result, [CallerMember
 
         private void ValidateResult(Double[] left, Double[] right, Double[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (BitConverter.DoubleToInt64Bits(result[0]) != BitConverter.DoubleToInt64Bits(left[1]))
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -391,19 +398,21 @@ private void ValidateResult(Double[] left, Double[] right, Double[] result, [Cal
                 {
                     if (BitConverter.DoubleToInt64Bits(result[3]) != BitConverter.DoubleToInt64Bits(right[2]))
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Avx)}.{nameof(Avx.Shuffle)}<Double>(Vector256<Double>.1, Vector256<Double>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx/Shuffle.Single.1.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx/Shuffle.Single.1.cs
index a03f08b078e8..9c37f537f06f 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Avx/Shuffle.Single.1.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx/Shuffle.Single.1.cs
@@ -341,7 +341,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -349,7 +349,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -381,9 +386,11 @@ private void ValidateResult(void* left, void* right, void* result, [CallerMember
 
         private void ValidateResult(Single[] left, Single[] right, Single[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (BitConverter.SingleToInt32Bits(result[0]) != BitConverter.SingleToInt32Bits(left[1]))
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -391,19 +398,21 @@ private void ValidateResult(Single[] left, Single[] right, Single[] result, [Cal
                 {
                     if (BitConverter.SingleToInt32Bits(result[7]) != BitConverter.SingleToInt32Bits(right[4]))
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Avx)}.{nameof(Avx.Shuffle)}<Single>(Vector256<Single>.1, Vector256<Single>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx/Subtract.Double.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx/Subtract.Double.cs
index 6d2a4390f554..de04ff933750 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Avx/Subtract.Double.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx/Subtract.Double.cs
@@ -334,7 +334,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -342,7 +342,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -374,9 +379,11 @@ private void ValidateResult(void* left, void* right, void* result, [CallerMember
 
         private void ValidateResult(Double[] left, Double[] right, Double[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (BitConverter.DoubleToInt64Bits(left[0] - right[0]) != BitConverter.DoubleToInt64Bits(result[0]))
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -384,19 +391,21 @@ private void ValidateResult(Double[] left, Double[] right, Double[] result, [Cal
                 {
                     if (BitConverter.DoubleToInt64Bits(left[i] - right[i]) != BitConverter.DoubleToInt64Bits(result[i]))
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Avx)}.{nameof(Avx.Subtract)}<Double>(Vector256<Double>, Vector256<Double>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx/Subtract.Single.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx/Subtract.Single.cs
index f1ba50bce5a8..cee2058df9e9 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Avx/Subtract.Single.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx/Subtract.Single.cs
@@ -334,7 +334,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -342,7 +342,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -374,9 +379,11 @@ private void ValidateResult(void* left, void* right, void* result, [CallerMember
 
         private void ValidateResult(Single[] left, Single[] right, Single[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (BitConverter.SingleToInt32Bits(left[0] - right[0]) != BitConverter.SingleToInt32Bits(result[0]))
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -384,19 +391,21 @@ private void ValidateResult(Single[] left, Single[] right, Single[] result, [Cal
                 {
                     if (BitConverter.SingleToInt32Bits(left[i] - right[i]) != BitConverter.SingleToInt32Bits(result[i]))
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Avx)}.{nameof(Avx.Subtract)}<Single>(Vector256<Single>, Vector256<Single>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx/TestC.Byte.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx/TestC.Byte.cs
index 99f3b92de5a1..86540e8a5f89 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Avx/TestC.Byte.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx/TestC.Byte.cs
@@ -329,7 +329,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -337,7 +337,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -374,13 +379,13 @@ private void ValidateResult(Byte[] left, Byte[] right, bool result, [CallerMembe
 
             if (expectedResult != result)
             {
-                Succeeded = false;
-
                 TestLibrary.TestFramework.LogInformation($"{nameof(Avx)}.{nameof(Avx.TestC)}<Byte>(Vector256<Byte>, Vector256<Byte>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx/TestC.Int16.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx/TestC.Int16.cs
index aff1b29c60d3..b4c601ab995b 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Avx/TestC.Int16.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx/TestC.Int16.cs
@@ -329,7 +329,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -337,7 +337,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -374,13 +379,13 @@ private void ValidateResult(Int16[] left, Int16[] right, bool result, [CallerMem
 
             if (expectedResult != result)
             {
-                Succeeded = false;
-
                 TestLibrary.TestFramework.LogInformation($"{nameof(Avx)}.{nameof(Avx.TestC)}<Int16>(Vector256<Int16>, Vector256<Int16>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx/TestC.Int32.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx/TestC.Int32.cs
index 9ee6568b0c14..86989640a611 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Avx/TestC.Int32.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx/TestC.Int32.cs
@@ -329,7 +329,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -337,7 +337,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -374,13 +379,13 @@ private void ValidateResult(Int32[] left, Int32[] right, bool result, [CallerMem
 
             if (expectedResult != result)
             {
-                Succeeded = false;
-
                 TestLibrary.TestFramework.LogInformation($"{nameof(Avx)}.{nameof(Avx.TestC)}<Int32>(Vector256<Int32>, Vector256<Int32>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx/TestC.Int64.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx/TestC.Int64.cs
index 1ad46c437162..90d1242971e1 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Avx/TestC.Int64.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx/TestC.Int64.cs
@@ -329,7 +329,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -337,7 +337,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -374,13 +379,13 @@ private void ValidateResult(Int64[] left, Int64[] right, bool result, [CallerMem
 
             if (expectedResult != result)
             {
-                Succeeded = false;
-
                 TestLibrary.TestFramework.LogInformation($"{nameof(Avx)}.{nameof(Avx.TestC)}<Int64>(Vector256<Int64>, Vector256<Int64>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx/TestC.SByte.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx/TestC.SByte.cs
index 7579e925a970..ebcbc6f58120 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Avx/TestC.SByte.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx/TestC.SByte.cs
@@ -329,7 +329,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -337,7 +337,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -374,13 +379,13 @@ private void ValidateResult(SByte[] left, SByte[] right, bool result, [CallerMem
 
             if (expectedResult != result)
             {
-                Succeeded = false;
-
                 TestLibrary.TestFramework.LogInformation($"{nameof(Avx)}.{nameof(Avx.TestC)}<SByte>(Vector256<SByte>, Vector256<SByte>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx/TestC.UInt16.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx/TestC.UInt16.cs
index a68483260670..8b3abb0116da 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Avx/TestC.UInt16.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx/TestC.UInt16.cs
@@ -329,7 +329,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -337,7 +337,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -374,13 +379,13 @@ private void ValidateResult(UInt16[] left, UInt16[] right, bool result, [CallerM
 
             if (expectedResult != result)
             {
-                Succeeded = false;
-
                 TestLibrary.TestFramework.LogInformation($"{nameof(Avx)}.{nameof(Avx.TestC)}<UInt16>(Vector256<UInt16>, Vector256<UInt16>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx/TestC.UInt32.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx/TestC.UInt32.cs
index 578cecb986dc..d61d540c1504 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Avx/TestC.UInt32.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx/TestC.UInt32.cs
@@ -329,7 +329,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -337,7 +337,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -374,13 +379,13 @@ private void ValidateResult(UInt32[] left, UInt32[] right, bool result, [CallerM
 
             if (expectedResult != result)
             {
-                Succeeded = false;
-
                 TestLibrary.TestFramework.LogInformation($"{nameof(Avx)}.{nameof(Avx.TestC)}<UInt32>(Vector256<UInt32>, Vector256<UInt32>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx/TestC.UInt64.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx/TestC.UInt64.cs
index c23bb64bfcad..10fbd839fb29 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Avx/TestC.UInt64.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx/TestC.UInt64.cs
@@ -329,7 +329,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -337,7 +337,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -374,13 +379,13 @@ private void ValidateResult(UInt64[] left, UInt64[] right, bool result, [CallerM
 
             if (expectedResult != result)
             {
-                Succeeded = false;
-
                 TestLibrary.TestFramework.LogInformation($"{nameof(Avx)}.{nameof(Avx.TestC)}<UInt64>(Vector256<UInt64>, Vector256<UInt64>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx/TestNotZAndNotC.Byte.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx/TestNotZAndNotC.Byte.cs
index decabff664be..9a5dedf7e83b 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Avx/TestNotZAndNotC.Byte.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx/TestNotZAndNotC.Byte.cs
@@ -329,7 +329,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -337,7 +337,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -381,13 +386,13 @@ private void ValidateResult(Byte[] left, Byte[] right, bool result, [CallerMembe
 
             if (((expectedResult1 == false) && (expectedResult2 == false)) != result)
             {
-                Succeeded = false;
-
                 TestLibrary.TestFramework.LogInformation($"{nameof(Avx)}.{nameof(Avx.TestNotZAndNotC)}<Byte>(Vector256<Byte>, Vector256<Byte>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx/TestNotZAndNotC.Int16.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx/TestNotZAndNotC.Int16.cs
index 2651d327c13b..bd819d7e0b08 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Avx/TestNotZAndNotC.Int16.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx/TestNotZAndNotC.Int16.cs
@@ -329,7 +329,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -337,7 +337,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -381,13 +386,13 @@ private void ValidateResult(Int16[] left, Int16[] right, bool result, [CallerMem
 
             if (((expectedResult1 == false) && (expectedResult2 == false)) != result)
             {
-                Succeeded = false;
-
                 TestLibrary.TestFramework.LogInformation($"{nameof(Avx)}.{nameof(Avx.TestNotZAndNotC)}<Int16>(Vector256<Int16>, Vector256<Int16>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx/TestNotZAndNotC.Int32.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx/TestNotZAndNotC.Int32.cs
index 4bc925583e77..41347cdbdb77 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Avx/TestNotZAndNotC.Int32.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx/TestNotZAndNotC.Int32.cs
@@ -329,7 +329,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -337,7 +337,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -381,13 +386,13 @@ private void ValidateResult(Int32[] left, Int32[] right, bool result, [CallerMem
 
             if (((expectedResult1 == false) && (expectedResult2 == false)) != result)
             {
-                Succeeded = false;
-
                 TestLibrary.TestFramework.LogInformation($"{nameof(Avx)}.{nameof(Avx.TestNotZAndNotC)}<Int32>(Vector256<Int32>, Vector256<Int32>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx/TestNotZAndNotC.Int64.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx/TestNotZAndNotC.Int64.cs
index b98e7df6f34e..4ddbea27e378 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Avx/TestNotZAndNotC.Int64.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx/TestNotZAndNotC.Int64.cs
@@ -329,7 +329,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -337,7 +337,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -381,13 +386,13 @@ private void ValidateResult(Int64[] left, Int64[] right, bool result, [CallerMem
 
             if (((expectedResult1 == false) && (expectedResult2 == false)) != result)
             {
-                Succeeded = false;
-
                 TestLibrary.TestFramework.LogInformation($"{nameof(Avx)}.{nameof(Avx.TestNotZAndNotC)}<Int64>(Vector256<Int64>, Vector256<Int64>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx/TestNotZAndNotC.SByte.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx/TestNotZAndNotC.SByte.cs
index 249f69d93ae5..8d0cc39f519d 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Avx/TestNotZAndNotC.SByte.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx/TestNotZAndNotC.SByte.cs
@@ -329,7 +329,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -337,7 +337,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -381,13 +386,13 @@ private void ValidateResult(SByte[] left, SByte[] right, bool result, [CallerMem
 
             if (((expectedResult1 == false) && (expectedResult2 == false)) != result)
             {
-                Succeeded = false;
-
                 TestLibrary.TestFramework.LogInformation($"{nameof(Avx)}.{nameof(Avx.TestNotZAndNotC)}<SByte>(Vector256<SByte>, Vector256<SByte>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx/TestNotZAndNotC.UInt16.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx/TestNotZAndNotC.UInt16.cs
index 1e172ce68ac6..b8cb5592de88 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Avx/TestNotZAndNotC.UInt16.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx/TestNotZAndNotC.UInt16.cs
@@ -329,7 +329,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -337,7 +337,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -381,13 +386,13 @@ private void ValidateResult(UInt16[] left, UInt16[] right, bool result, [CallerM
 
             if (((expectedResult1 == false) && (expectedResult2 == false)) != result)
             {
-                Succeeded = false;
-
                 TestLibrary.TestFramework.LogInformation($"{nameof(Avx)}.{nameof(Avx.TestNotZAndNotC)}<UInt16>(Vector256<UInt16>, Vector256<UInt16>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx/TestNotZAndNotC.UInt32.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx/TestNotZAndNotC.UInt32.cs
index b89594d0e335..cee7a3f4261a 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Avx/TestNotZAndNotC.UInt32.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx/TestNotZAndNotC.UInt32.cs
@@ -329,7 +329,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -337,7 +337,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -381,13 +386,13 @@ private void ValidateResult(UInt32[] left, UInt32[] right, bool result, [CallerM
 
             if (((expectedResult1 == false) && (expectedResult2 == false)) != result)
             {
-                Succeeded = false;
-
                 TestLibrary.TestFramework.LogInformation($"{nameof(Avx)}.{nameof(Avx.TestNotZAndNotC)}<UInt32>(Vector256<UInt32>, Vector256<UInt32>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx/TestNotZAndNotC.UInt64.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx/TestNotZAndNotC.UInt64.cs
index 14c874bf221d..09df7060387c 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Avx/TestNotZAndNotC.UInt64.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx/TestNotZAndNotC.UInt64.cs
@@ -329,7 +329,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -337,7 +337,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -381,13 +386,13 @@ private void ValidateResult(UInt64[] left, UInt64[] right, bool result, [CallerM
 
             if (((expectedResult1 == false) && (expectedResult2 == false)) != result)
             {
-                Succeeded = false;
-
                 TestLibrary.TestFramework.LogInformation($"{nameof(Avx)}.{nameof(Avx.TestNotZAndNotC)}<UInt64>(Vector256<UInt64>, Vector256<UInt64>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx/TestZ.Byte.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx/TestZ.Byte.cs
index 0ba1d262d9b8..7ad93036032a 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Avx/TestZ.Byte.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx/TestZ.Byte.cs
@@ -329,7 +329,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -337,7 +337,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -374,13 +379,13 @@ private void ValidateResult(Byte[] left, Byte[] right, bool result, [CallerMembe
 
             if (expectedResult != result)
             {
-                Succeeded = false;
-
                 TestLibrary.TestFramework.LogInformation($"{nameof(Avx)}.{nameof(Avx.TestZ)}<Byte>(Vector256<Byte>, Vector256<Byte>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx/TestZ.Int16.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx/TestZ.Int16.cs
index 3c3ed417ea59..07ca6aeb50e5 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Avx/TestZ.Int16.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx/TestZ.Int16.cs
@@ -329,7 +329,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -337,7 +337,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -374,13 +379,13 @@ private void ValidateResult(Int16[] left, Int16[] right, bool result, [CallerMem
 
             if (expectedResult != result)
             {
-                Succeeded = false;
-
                 TestLibrary.TestFramework.LogInformation($"{nameof(Avx)}.{nameof(Avx.TestZ)}<Int16>(Vector256<Int16>, Vector256<Int16>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx/TestZ.Int32.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx/TestZ.Int32.cs
index 97e24d09e681..770ffc34442f 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Avx/TestZ.Int32.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx/TestZ.Int32.cs
@@ -329,7 +329,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -337,7 +337,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -374,13 +379,13 @@ private void ValidateResult(Int32[] left, Int32[] right, bool result, [CallerMem
 
             if (expectedResult != result)
             {
-                Succeeded = false;
-
                 TestLibrary.TestFramework.LogInformation($"{nameof(Avx)}.{nameof(Avx.TestZ)}<Int32>(Vector256<Int32>, Vector256<Int32>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx/TestZ.Int64.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx/TestZ.Int64.cs
index 82e47899590a..1983047589f6 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Avx/TestZ.Int64.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx/TestZ.Int64.cs
@@ -329,7 +329,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -337,7 +337,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -374,13 +379,13 @@ private void ValidateResult(Int64[] left, Int64[] right, bool result, [CallerMem
 
             if (expectedResult != result)
             {
-                Succeeded = false;
-
                 TestLibrary.TestFramework.LogInformation($"{nameof(Avx)}.{nameof(Avx.TestZ)}<Int64>(Vector256<Int64>, Vector256<Int64>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx/TestZ.SByte.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx/TestZ.SByte.cs
index b7daa05bbe7f..90415ed31b62 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Avx/TestZ.SByte.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx/TestZ.SByte.cs
@@ -329,7 +329,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -337,7 +337,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -374,13 +379,13 @@ private void ValidateResult(SByte[] left, SByte[] right, bool result, [CallerMem
 
             if (expectedResult != result)
             {
-                Succeeded = false;
-
                 TestLibrary.TestFramework.LogInformation($"{nameof(Avx)}.{nameof(Avx.TestZ)}<SByte>(Vector256<SByte>, Vector256<SByte>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx/TestZ.UInt16.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx/TestZ.UInt16.cs
index 38e9ef21f9bb..9e18b76619d2 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Avx/TestZ.UInt16.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx/TestZ.UInt16.cs
@@ -329,7 +329,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -337,7 +337,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -374,13 +379,13 @@ private void ValidateResult(UInt16[] left, UInt16[] right, bool result, [CallerM
 
             if (expectedResult != result)
             {
-                Succeeded = false;
-
                 TestLibrary.TestFramework.LogInformation($"{nameof(Avx)}.{nameof(Avx.TestZ)}<UInt16>(Vector256<UInt16>, Vector256<UInt16>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx/TestZ.UInt32.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx/TestZ.UInt32.cs
index 58b249974cbf..d83945e3eac6 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Avx/TestZ.UInt32.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx/TestZ.UInt32.cs
@@ -329,7 +329,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -337,7 +337,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -374,13 +379,13 @@ private void ValidateResult(UInt32[] left, UInt32[] right, bool result, [CallerM
 
             if (expectedResult != result)
             {
-                Succeeded = false;
-
                 TestLibrary.TestFramework.LogInformation($"{nameof(Avx)}.{nameof(Avx.TestZ)}<UInt32>(Vector256<UInt32>, Vector256<UInt32>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx/TestZ.UInt64.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx/TestZ.UInt64.cs
index b7d0b7d38dcc..45e263c6a0cc 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Avx/TestZ.UInt64.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx/TestZ.UInt64.cs
@@ -329,7 +329,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -337,7 +337,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -374,13 +379,13 @@ private void ValidateResult(UInt64[] left, UInt64[] right, bool result, [CallerM
 
             if (expectedResult != result)
             {
-                Succeeded = false;
-
                 TestLibrary.TestFramework.LogInformation($"{nameof(Avx)}.{nameof(Avx.TestZ)}<UInt64>(Vector256<UInt64>, Vector256<UInt64>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx/Xor.Double.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx/Xor.Double.cs
index 6970cee29802..abd14a41778f 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Avx/Xor.Double.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx/Xor.Double.cs
@@ -334,7 +334,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -342,7 +342,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -374,9 +379,11 @@ private void ValidateResult(void* left, void* right, void* result, [CallerMember
 
         private void ValidateResult(Double[] left, Double[] right, Double[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if ((BitConverter.DoubleToInt64Bits(left[0]) ^ BitConverter.DoubleToInt64Bits(right[0])) != BitConverter.DoubleToInt64Bits(result[0]))
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -384,19 +391,21 @@ private void ValidateResult(Double[] left, Double[] right, Double[] result, [Cal
                 {
                     if ((BitConverter.DoubleToInt64Bits(left[i]) ^ BitConverter.DoubleToInt64Bits(right[i])) != BitConverter.DoubleToInt64Bits(result[i]))
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Avx)}.{nameof(Avx.Xor)}<Double>(Vector256<Double>, Vector256<Double>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx/Xor.Single.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx/Xor.Single.cs
index 1789c561f41f..24c785b29bc1 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Avx/Xor.Single.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx/Xor.Single.cs
@@ -334,7 +334,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -342,7 +342,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -374,9 +379,11 @@ private void ValidateResult(void* left, void* right, void* result, [CallerMember
 
         private void ValidateResult(Single[] left, Single[] right, Single[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if ((BitConverter.SingleToInt32Bits(left[0]) ^ BitConverter.SingleToInt32Bits(right[0])) != BitConverter.SingleToInt32Bits(result[0]))
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -384,19 +391,21 @@ private void ValidateResult(Single[] left, Single[] right, Single[] result, [Cal
                 {
                     if ((BitConverter.SingleToInt32Bits(left[i]) ^ BitConverter.SingleToInt32Bits(right[i])) != BitConverter.SingleToInt32Bits(result[i]))
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Avx)}.{nameof(Avx.Xor)}<Single>(Vector256<Single>, Vector256<Single>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Add.Byte.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Add.Byte.cs
index 4a52e700c5d9..3b940b0643f3 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Add.Byte.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Add.Byte.cs
@@ -334,7 +334,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -342,7 +342,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -374,9 +379,11 @@ private void ValidateResult(void* left, void* right, void* result, [CallerMember
 
         private void ValidateResult(Byte[] left, Byte[] right, Byte[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if ((byte)(left[0] + right[0]) != result[0])
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -384,19 +391,21 @@ private void ValidateResult(Byte[] left, Byte[] right, Byte[] result, [CallerMem
                 {
                     if ((byte)(left[i] + right[i]) != result[i])
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Avx2)}.{nameof(Avx2.Add)}<Byte>(Vector256<Byte>, Vector256<Byte>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Add.Int16.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Add.Int16.cs
index 2697e12dd983..04e7aed13e48 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Add.Int16.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Add.Int16.cs
@@ -334,7 +334,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -342,7 +342,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -374,9 +379,11 @@ private void ValidateResult(void* left, void* right, void* result, [CallerMember
 
         private void ValidateResult(Int16[] left, Int16[] right, Int16[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if ((short)(left[0] + right[0]) != result[0])
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -384,19 +391,21 @@ private void ValidateResult(Int16[] left, Int16[] right, Int16[] result, [Caller
                 {
                     if ((short)(left[i] + right[i]) != result[i])
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Avx2)}.{nameof(Avx2.Add)}<Int16>(Vector256<Int16>, Vector256<Int16>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Add.Int32.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Add.Int32.cs
index 90779f2d2cfa..d91eb985e590 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Add.Int32.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Add.Int32.cs
@@ -334,7 +334,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -342,7 +342,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -374,9 +379,11 @@ private void ValidateResult(void* left, void* right, void* result, [CallerMember
 
         private void ValidateResult(Int32[] left, Int32[] right, Int32[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if ((int)(left[0] + right[0]) != result[0])
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -384,19 +391,21 @@ private void ValidateResult(Int32[] left, Int32[] right, Int32[] result, [Caller
                 {
                     if ((int)(left[i] + right[i]) != result[i])
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Avx2)}.{nameof(Avx2.Add)}<Int32>(Vector256<Int32>, Vector256<Int32>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Add.Int64.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Add.Int64.cs
index b1d599e8a0ac..4469f2463061 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Add.Int64.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Add.Int64.cs
@@ -334,7 +334,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -342,7 +342,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -374,9 +379,11 @@ private void ValidateResult(void* left, void* right, void* result, [CallerMember
 
         private void ValidateResult(Int64[] left, Int64[] right, Int64[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if ((long)(left[0] + right[0]) != result[0])
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -384,19 +391,21 @@ private void ValidateResult(Int64[] left, Int64[] right, Int64[] result, [Caller
                 {
                     if ((long)(left[i] + right[i]) != result[i])
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Avx2)}.{nameof(Avx2.Add)}<Int64>(Vector256<Int64>, Vector256<Int64>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Add.SByte.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Add.SByte.cs
index 3c50a11404d6..f64e13cc1d95 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Add.SByte.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Add.SByte.cs
@@ -334,7 +334,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -342,7 +342,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -374,9 +379,11 @@ private void ValidateResult(void* left, void* right, void* result, [CallerMember
 
         private void ValidateResult(SByte[] left, SByte[] right, SByte[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if ((sbyte)(left[0] + right[0]) != result[0])
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -384,19 +391,21 @@ private void ValidateResult(SByte[] left, SByte[] right, SByte[] result, [Caller
                 {
                     if ((sbyte)(left[i] + right[i]) != result[i])
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Avx2)}.{nameof(Avx2.Add)}<SByte>(Vector256<SByte>, Vector256<SByte>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Add.UInt16.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Add.UInt16.cs
index 956cb0da95ab..0b8166b20a02 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Add.UInt16.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Add.UInt16.cs
@@ -334,7 +334,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -342,7 +342,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -374,9 +379,11 @@ private void ValidateResult(void* left, void* right, void* result, [CallerMember
 
         private void ValidateResult(UInt16[] left, UInt16[] right, UInt16[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if ((ushort)(left[0] + right[0]) != result[0])
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -384,19 +391,21 @@ private void ValidateResult(UInt16[] left, UInt16[] right, UInt16[] result, [Cal
                 {
                     if ((ushort)(left[i] + right[i]) != result[i])
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Avx2)}.{nameof(Avx2.Add)}<UInt16>(Vector256<UInt16>, Vector256<UInt16>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Add.UInt32.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Add.UInt32.cs
index f34d74322c30..15258a6be45e 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Add.UInt32.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Add.UInt32.cs
@@ -334,7 +334,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -342,7 +342,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -374,9 +379,11 @@ private void ValidateResult(void* left, void* right, void* result, [CallerMember
 
         private void ValidateResult(UInt32[] left, UInt32[] right, UInt32[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if ((uint)(left[0] + right[0]) != result[0])
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -384,19 +391,21 @@ private void ValidateResult(UInt32[] left, UInt32[] right, UInt32[] result, [Cal
                 {
                     if ((uint)(left[i] + right[i]) != result[i])
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Avx2)}.{nameof(Avx2.Add)}<UInt32>(Vector256<UInt32>, Vector256<UInt32>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Add.UInt64.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Add.UInt64.cs
index 679d863515c4..09f950de5a27 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Add.UInt64.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Add.UInt64.cs
@@ -334,7 +334,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -342,7 +342,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -374,9 +379,11 @@ private void ValidateResult(void* left, void* right, void* result, [CallerMember
 
         private void ValidateResult(UInt64[] left, UInt64[] right, UInt64[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if ((ulong)(left[0] + right[0]) != result[0])
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -384,19 +391,21 @@ private void ValidateResult(UInt64[] left, UInt64[] right, UInt64[] result, [Cal
                 {
                     if ((ulong)(left[i] + right[i]) != result[i])
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Avx2)}.{nameof(Avx2.Add)}<UInt64>(Vector256<UInt64>, Vector256<UInt64>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/AlignRight.Byte.228.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/AlignRight.Byte.228.cs
index a9b5c54a022a..564c88142df6 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/AlignRight.Byte.228.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/AlignRight.Byte.228.cs
@@ -341,7 +341,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -349,7 +349,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -381,9 +386,11 @@ private void ValidateResult(void* left, void* right, void* result, [CallerMember
 
         private void ValidateResult(Byte[] left, Byte[] right, Byte[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (result[0] != 0)
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -391,19 +398,21 @@ private void ValidateResult(Byte[] left, Byte[] right, Byte[] result, [CallerMem
                 {
                     if (result[i] != 0)
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Avx2)}.{nameof(Avx2.AlignRight)}<Byte>(Vector256<Byte>.228, Vector256<Byte>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/AlignRight.Byte.250.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/AlignRight.Byte.250.cs
index 640f2df61a32..d9dffdfc1882 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/AlignRight.Byte.250.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/AlignRight.Byte.250.cs
@@ -341,7 +341,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -349,7 +349,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -381,9 +386,11 @@ private void ValidateResult(void* left, void* right, void* result, [CallerMember
 
         private void ValidateResult(Byte[] left, Byte[] right, Byte[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (result[0] != 0)
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -391,19 +398,21 @@ private void ValidateResult(Byte[] left, Byte[] right, Byte[] result, [CallerMem
                 {
                     if (result[i] != 0)
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Avx2)}.{nameof(Avx2.AlignRight)}<Byte>(Vector256<Byte>.250, Vector256<Byte>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/AlignRight.Byte.27.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/AlignRight.Byte.27.cs
index cf81b13a756d..44aae356abe0 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/AlignRight.Byte.27.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/AlignRight.Byte.27.cs
@@ -341,7 +341,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -349,7 +349,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -381,9 +386,11 @@ private void ValidateResult(void* left, void* right, void* result, [CallerMember
 
         private void ValidateResult(Byte[] left, Byte[] right, Byte[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (result[0] != left[11])
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -391,19 +398,21 @@ private void ValidateResult(Byte[] left, Byte[] right, Byte[] result, [CallerMem
                 {
                     if ((result[i] != ((i < 16) ? ((i < 5) ? left[i + 11] : 0) : ((i < 21) ? left[i + 11] : 0))))
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Avx2)}.{nameof(Avx2.AlignRight)}<Byte>(Vector256<Byte>.27, Vector256<Byte>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/AlignRight.Byte.5.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/AlignRight.Byte.5.cs
index 678bbd0ab6b8..4c171d0d6760 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/AlignRight.Byte.5.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/AlignRight.Byte.5.cs
@@ -341,7 +341,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -349,7 +349,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -381,9 +386,11 @@ private void ValidateResult(void* left, void* right, void* result, [CallerMember
 
         private void ValidateResult(Byte[] left, Byte[] right, Byte[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (result[0] != right[5])
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -391,19 +398,21 @@ private void ValidateResult(Byte[] left, Byte[] right, Byte[] result, [CallerMem
                 {
                     if ((result[i] != ((i < 16) ? ((i < 11) ? right[i + 5] : left[i - 11]) : ((i < 27) ? right[i + 5] : left[i - 11]))))
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Avx2)}.{nameof(Avx2.AlignRight)}<Byte>(Vector256<Byte>.5, Vector256<Byte>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/AlignRight.Int16.0.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/AlignRight.Int16.0.cs
index b4cdccf0d9cd..945ac5102169 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/AlignRight.Int16.0.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/AlignRight.Int16.0.cs
@@ -341,7 +341,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -349,7 +349,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -381,9 +386,11 @@ private void ValidateResult(void* left, void* right, void* result, [CallerMember
 
         private void ValidateResult(Int16[] left, Int16[] right, Int16[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (result[0] != right[0])
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -391,19 +398,21 @@ private void ValidateResult(Int16[] left, Int16[] right, Int16[] result, [Caller
                 {
                     if (result[i] != right[i])
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Avx2)}.{nameof(Avx2.AlignRight)}<Int16>(Vector256<Int16>.0, Vector256<Int16>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/AlignRight.Int16.2.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/AlignRight.Int16.2.cs
index 8ef25a30bcdf..9114cfde686f 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/AlignRight.Int16.2.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/AlignRight.Int16.2.cs
@@ -341,7 +341,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -349,7 +349,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -381,9 +386,11 @@ private void ValidateResult(void* left, void* right, void* result, [CallerMember
 
         private void ValidateResult(Int16[] left, Int16[] right, Int16[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (result[0] != right[1])
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -391,19 +398,21 @@ private void ValidateResult(Int16[] left, Int16[] right, Int16[] result, [Caller
                 {
                     if (result[i] != (i < 8 ? (i == 7 ? left[0] : right[i+1]) : (i == 15 ? left[8] : right[i+1])))
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Avx2)}.{nameof(Avx2.AlignRight)}<Int16>(Vector256<Int16>.2, Vector256<Int16>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/AlignRight.Int32.0.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/AlignRight.Int32.0.cs
index 9d7cd9c9470c..27efb1d833ab 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/AlignRight.Int32.0.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/AlignRight.Int32.0.cs
@@ -341,7 +341,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -349,7 +349,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -381,9 +386,11 @@ private void ValidateResult(void* left, void* right, void* result, [CallerMember
 
         private void ValidateResult(Int32[] left, Int32[] right, Int32[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (result[0] != right[0])
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -391,19 +398,21 @@ private void ValidateResult(Int32[] left, Int32[] right, Int32[] result, [Caller
                 {
                     if (result[i] != right[i])
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Avx2)}.{nameof(Avx2.AlignRight)}<Int32>(Vector256<Int32>.0, Vector256<Int32>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/AlignRight.Int32.4.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/AlignRight.Int32.4.cs
index 8e8ed30ce78c..a2a0f804a65d 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/AlignRight.Int32.4.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/AlignRight.Int32.4.cs
@@ -341,7 +341,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -349,7 +349,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -381,9 +386,11 @@ private void ValidateResult(void* left, void* right, void* result, [CallerMember
 
         private void ValidateResult(Int32[] left, Int32[] right, Int32[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (result[0] != right[1])
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -391,19 +398,21 @@ private void ValidateResult(Int32[] left, Int32[] right, Int32[] result, [Caller
                 {
                     if (result[i] != (i < 4 ? (i == 3 ? left[0] : right[i+1]) : (i == 7 ? left[4] : right[i+1])))
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Avx2)}.{nameof(Avx2.AlignRight)}<Int32>(Vector256<Int32>.4, Vector256<Int32>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/AlignRight.Int64.0.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/AlignRight.Int64.0.cs
index 86eb1c08ece8..5386b0db7a56 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/AlignRight.Int64.0.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/AlignRight.Int64.0.cs
@@ -341,7 +341,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -349,7 +349,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -381,9 +386,11 @@ private void ValidateResult(void* left, void* right, void* result, [CallerMember
 
         private void ValidateResult(Int64[] left, Int64[] right, Int64[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (result[0] != right[0])
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -391,19 +398,21 @@ private void ValidateResult(Int64[] left, Int64[] right, Int64[] result, [Caller
                 {
                     if (result[i] != right[i])
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Avx2)}.{nameof(Avx2.AlignRight)}<Int64>(Vector256<Int64>.0, Vector256<Int64>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/AlignRight.Int64.8.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/AlignRight.Int64.8.cs
index 9382c5744856..fbe827d25ba0 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/AlignRight.Int64.8.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/AlignRight.Int64.8.cs
@@ -341,7 +341,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -349,7 +349,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -381,9 +386,11 @@ private void ValidateResult(void* left, void* right, void* result, [CallerMember
 
         private void ValidateResult(Int64[] left, Int64[] right, Int64[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (result[0] != right[1])
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -391,19 +398,21 @@ private void ValidateResult(Int64[] left, Int64[] right, Int64[] result, [Caller
                 {
                     if (result[i] != (i < 2 ? (i == 1 ? left[0] : right[i+1]) : (i == 3 ? left[2] : right[i+1])))
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Avx2)}.{nameof(Avx2.AlignRight)}<Int64>(Vector256<Int64>.8, Vector256<Int64>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/AlignRight.SByte.228.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/AlignRight.SByte.228.cs
index ee08253331fd..86f110d0f169 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/AlignRight.SByte.228.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/AlignRight.SByte.228.cs
@@ -341,7 +341,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -349,7 +349,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -381,9 +386,11 @@ private void ValidateResult(void* left, void* right, void* result, [CallerMember
 
         private void ValidateResult(SByte[] left, SByte[] right, SByte[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (result[0] != 0)
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -391,19 +398,21 @@ private void ValidateResult(SByte[] left, SByte[] right, SByte[] result, [Caller
                 {
                     if (result[i] != 0)
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Avx2)}.{nameof(Avx2.AlignRight)}<SByte>(Vector256<SByte>.228, Vector256<SByte>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/AlignRight.SByte.250.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/AlignRight.SByte.250.cs
index eacf55a73ad9..484bbd9bc72f 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/AlignRight.SByte.250.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/AlignRight.SByte.250.cs
@@ -341,7 +341,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -349,7 +349,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -381,9 +386,11 @@ private void ValidateResult(void* left, void* right, void* result, [CallerMember
 
         private void ValidateResult(SByte[] left, SByte[] right, SByte[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (result[0] != 0)
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -391,19 +398,21 @@ private void ValidateResult(SByte[] left, SByte[] right, SByte[] result, [Caller
                 {
                     if (result[i] != 0)
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Avx2)}.{nameof(Avx2.AlignRight)}<SByte>(Vector256<SByte>.250, Vector256<SByte>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/AlignRight.SByte.27.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/AlignRight.SByte.27.cs
index 3a7ffe29304e..8b9a5811e0a4 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/AlignRight.SByte.27.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/AlignRight.SByte.27.cs
@@ -341,7 +341,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -349,7 +349,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -381,9 +386,11 @@ private void ValidateResult(void* left, void* right, void* result, [CallerMember
 
         private void ValidateResult(SByte[] left, SByte[] right, SByte[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (result[0] != left[11])
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -391,19 +398,21 @@ private void ValidateResult(SByte[] left, SByte[] right, SByte[] result, [Caller
                 {
                     if ((result[i] != ((i < 16) ? ((i < 5) ? left[i + 11] : 0) : ((i < 21) ? left[i + 11] : 0))))
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Avx2)}.{nameof(Avx2.AlignRight)}<SByte>(Vector256<SByte>.27, Vector256<SByte>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/AlignRight.SByte.5.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/AlignRight.SByte.5.cs
index 722992cadf9d..fde0195918d1 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/AlignRight.SByte.5.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/AlignRight.SByte.5.cs
@@ -341,7 +341,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -349,7 +349,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -381,9 +386,11 @@ private void ValidateResult(void* left, void* right, void* result, [CallerMember
 
         private void ValidateResult(SByte[] left, SByte[] right, SByte[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (result[0] != right[5])
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -391,19 +398,21 @@ private void ValidateResult(SByte[] left, SByte[] right, SByte[] result, [Caller
                 {
                     if ((result[i] != ((i < 16) ? ((i < 11) ? right[i + 5] : left[i - 11]) : ((i < 27) ? right[i + 5] : left[i - 11]))))
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Avx2)}.{nameof(Avx2.AlignRight)}<SByte>(Vector256<SByte>.5, Vector256<SByte>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/AlignRight.UInt16.0.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/AlignRight.UInt16.0.cs
index 92f12b5b3b79..649971636b8c 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/AlignRight.UInt16.0.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/AlignRight.UInt16.0.cs
@@ -341,7 +341,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -349,7 +349,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -381,9 +386,11 @@ private void ValidateResult(void* left, void* right, void* result, [CallerMember
 
         private void ValidateResult(UInt16[] left, UInt16[] right, UInt16[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (result[0] != right[0])
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -391,19 +398,21 @@ private void ValidateResult(UInt16[] left, UInt16[] right, UInt16[] result, [Cal
                 {
                     if (result[i] != right[i])
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Avx2)}.{nameof(Avx2.AlignRight)}<UInt16>(Vector256<UInt16>.0, Vector256<UInt16>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/AlignRight.UInt16.2.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/AlignRight.UInt16.2.cs
index 128c4878fa06..40d52428fe59 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/AlignRight.UInt16.2.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/AlignRight.UInt16.2.cs
@@ -341,7 +341,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -349,7 +349,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -381,9 +386,11 @@ private void ValidateResult(void* left, void* right, void* result, [CallerMember
 
         private void ValidateResult(UInt16[] left, UInt16[] right, UInt16[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (result[0] != right[1])
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -391,19 +398,21 @@ private void ValidateResult(UInt16[] left, UInt16[] right, UInt16[] result, [Cal
                 {
                     if (result[i] != (i < 8 ? (i == 7 ? left[0] : right[i+1]) : (i == 15 ? left[8] : right[i+1])))
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Avx2)}.{nameof(Avx2.AlignRight)}<UInt16>(Vector256<UInt16>.2, Vector256<UInt16>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/AlignRight.UInt32.0.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/AlignRight.UInt32.0.cs
index 1fdf7b18695f..c2696818bd85 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/AlignRight.UInt32.0.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/AlignRight.UInt32.0.cs
@@ -341,7 +341,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -349,7 +349,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -381,9 +386,11 @@ private void ValidateResult(void* left, void* right, void* result, [CallerMember
 
         private void ValidateResult(UInt32[] left, UInt32[] right, UInt32[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (result[0] != right[0])
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -391,19 +398,21 @@ private void ValidateResult(UInt32[] left, UInt32[] right, UInt32[] result, [Cal
                 {
                     if (result[i] != right[i])
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Avx2)}.{nameof(Avx2.AlignRight)}<UInt32>(Vector256<UInt32>.0, Vector256<UInt32>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/AlignRight.UInt32.4.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/AlignRight.UInt32.4.cs
index 13d20361b4e7..ca5ae7f53f02 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/AlignRight.UInt32.4.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/AlignRight.UInt32.4.cs
@@ -341,7 +341,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -349,7 +349,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -381,9 +386,11 @@ private void ValidateResult(void* left, void* right, void* result, [CallerMember
 
         private void ValidateResult(UInt32[] left, UInt32[] right, UInt32[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (result[0] != right[1])
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -391,19 +398,21 @@ private void ValidateResult(UInt32[] left, UInt32[] right, UInt32[] result, [Cal
                 {
                     if (result[i] != (i < 4 ? (i == 3 ? left[0] : right[i+1]) : (i == 7 ? left[4] : right[i+1])))
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Avx2)}.{nameof(Avx2.AlignRight)}<UInt32>(Vector256<UInt32>.4, Vector256<UInt32>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/AlignRight.UInt64.0.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/AlignRight.UInt64.0.cs
index d47d65c89d55..e21658e1a7bd 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/AlignRight.UInt64.0.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/AlignRight.UInt64.0.cs
@@ -341,7 +341,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -349,7 +349,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -381,9 +386,11 @@ private void ValidateResult(void* left, void* right, void* result, [CallerMember
 
         private void ValidateResult(UInt64[] left, UInt64[] right, UInt64[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (result[0] != right[0])
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -391,19 +398,21 @@ private void ValidateResult(UInt64[] left, UInt64[] right, UInt64[] result, [Cal
                 {
                     if (result[i] != right[i])
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Avx2)}.{nameof(Avx2.AlignRight)}<UInt64>(Vector256<UInt64>.0, Vector256<UInt64>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/AlignRight.UInt64.8.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/AlignRight.UInt64.8.cs
index 1c888545e5ab..17d5fe821844 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/AlignRight.UInt64.8.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/AlignRight.UInt64.8.cs
@@ -341,7 +341,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -349,7 +349,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -381,9 +386,11 @@ private void ValidateResult(void* left, void* right, void* result, [CallerMember
 
         private void ValidateResult(UInt64[] left, UInt64[] right, UInt64[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (result[0] != right[1])
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -391,19 +398,21 @@ private void ValidateResult(UInt64[] left, UInt64[] right, UInt64[] result, [Cal
                 {
                     if (result[i] != (i < 2 ? (i == 1 ? left[0] : right[i+1]) : (i == 3 ? left[2] : right[i+1])))
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Avx2)}.{nameof(Avx2.AlignRight)}<UInt64>(Vector256<UInt64>.8, Vector256<UInt64>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/And.Byte.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/And.Byte.cs
index b0f6244412b1..8855c8af4aa6 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/And.Byte.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/And.Byte.cs
@@ -334,7 +334,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -342,7 +342,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -374,9 +379,11 @@ private void ValidateResult(void* left, void* right, void* result, [CallerMember
 
         private void ValidateResult(Byte[] left, Byte[] right, Byte[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if ((byte)(left[0] & right[0]) != result[0])
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -384,19 +391,21 @@ private void ValidateResult(Byte[] left, Byte[] right, Byte[] result, [CallerMem
                 {
                     if ((byte)(left[i] & right[i]) != result[i])
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Avx2)}.{nameof(Avx2.And)}<Byte>(Vector256<Byte>, Vector256<Byte>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/And.Int16.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/And.Int16.cs
index 260c3feae360..391995d4a950 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/And.Int16.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/And.Int16.cs
@@ -334,7 +334,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -342,7 +342,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -374,9 +379,11 @@ private void ValidateResult(void* left, void* right, void* result, [CallerMember
 
         private void ValidateResult(Int16[] left, Int16[] right, Int16[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if ((short)(left[0] & right[0]) != result[0])
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -384,19 +391,21 @@ private void ValidateResult(Int16[] left, Int16[] right, Int16[] result, [Caller
                 {
                     if ((short)(left[i] & right[i]) != result[i])
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Avx2)}.{nameof(Avx2.And)}<Int16>(Vector256<Int16>, Vector256<Int16>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/And.Int32.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/And.Int32.cs
index 8f4c33ba70bd..4050291a58e4 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/And.Int32.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/And.Int32.cs
@@ -334,7 +334,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -342,7 +342,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -374,9 +379,11 @@ private void ValidateResult(void* left, void* right, void* result, [CallerMember
 
         private void ValidateResult(Int32[] left, Int32[] right, Int32[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if ((int)(left[0] & right[0]) != result[0])
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -384,19 +391,21 @@ private void ValidateResult(Int32[] left, Int32[] right, Int32[] result, [Caller
                 {
                     if ((int)(left[i] & right[i]) != result[i])
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Avx2)}.{nameof(Avx2.And)}<Int32>(Vector256<Int32>, Vector256<Int32>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/And.Int64.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/And.Int64.cs
index 6547a3109683..fb172a197bc5 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/And.Int64.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/And.Int64.cs
@@ -334,7 +334,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -342,7 +342,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -374,9 +379,11 @@ private void ValidateResult(void* left, void* right, void* result, [CallerMember
 
         private void ValidateResult(Int64[] left, Int64[] right, Int64[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if ((long)(left[0] & right[0]) != result[0])
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -384,19 +391,21 @@ private void ValidateResult(Int64[] left, Int64[] right, Int64[] result, [Caller
                 {
                     if ((long)(left[i] & right[i]) != result[i])
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Avx2)}.{nameof(Avx2.And)}<Int64>(Vector256<Int64>, Vector256<Int64>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/And.SByte.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/And.SByte.cs
index 1e161c11084d..cfa052db4308 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/And.SByte.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/And.SByte.cs
@@ -334,7 +334,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -342,7 +342,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -374,9 +379,11 @@ private void ValidateResult(void* left, void* right, void* result, [CallerMember
 
         private void ValidateResult(SByte[] left, SByte[] right, SByte[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if ((sbyte)(left[0] & right[0]) != result[0])
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -384,19 +391,21 @@ private void ValidateResult(SByte[] left, SByte[] right, SByte[] result, [Caller
                 {
                     if ((sbyte)(left[i] & right[i]) != result[i])
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Avx2)}.{nameof(Avx2.And)}<SByte>(Vector256<SByte>, Vector256<SByte>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/And.UInt16.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/And.UInt16.cs
index 551105b4b5f9..10a6043ec39c 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/And.UInt16.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/And.UInt16.cs
@@ -334,7 +334,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -342,7 +342,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -374,9 +379,11 @@ private void ValidateResult(void* left, void* right, void* result, [CallerMember
 
         private void ValidateResult(UInt16[] left, UInt16[] right, UInt16[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if ((ushort)(left[0] & right[0]) != result[0])
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -384,19 +391,21 @@ private void ValidateResult(UInt16[] left, UInt16[] right, UInt16[] result, [Cal
                 {
                     if ((ushort)(left[i] & right[i]) != result[i])
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Avx2)}.{nameof(Avx2.And)}<UInt16>(Vector256<UInt16>, Vector256<UInt16>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/And.UInt32.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/And.UInt32.cs
index 96e3ff73d963..69a29c38c00f 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/And.UInt32.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/And.UInt32.cs
@@ -334,7 +334,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -342,7 +342,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -374,9 +379,11 @@ private void ValidateResult(void* left, void* right, void* result, [CallerMember
 
         private void ValidateResult(UInt32[] left, UInt32[] right, UInt32[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if ((uint)(left[0] & right[0]) != result[0])
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -384,19 +391,21 @@ private void ValidateResult(UInt32[] left, UInt32[] right, UInt32[] result, [Cal
                 {
                     if ((uint)(left[i] & right[i]) != result[i])
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Avx2)}.{nameof(Avx2.And)}<UInt32>(Vector256<UInt32>, Vector256<UInt32>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/And.UInt64.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/And.UInt64.cs
index ad1b44af5c48..ecd5d1621bd9 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/And.UInt64.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/And.UInt64.cs
@@ -334,7 +334,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -342,7 +342,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -374,9 +379,11 @@ private void ValidateResult(void* left, void* right, void* result, [CallerMember
 
         private void ValidateResult(UInt64[] left, UInt64[] right, UInt64[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if ((ulong)(left[0] & right[0]) != result[0])
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -384,19 +391,21 @@ private void ValidateResult(UInt64[] left, UInt64[] right, UInt64[] result, [Cal
                 {
                     if ((ulong)(left[i] & right[i]) != result[i])
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Avx2)}.{nameof(Avx2.And)}<UInt64>(Vector256<UInt64>, Vector256<UInt64>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/AndNot.Byte.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/AndNot.Byte.cs
index 97d155d704ab..18d7da51afa6 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/AndNot.Byte.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/AndNot.Byte.cs
@@ -334,7 +334,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -342,7 +342,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -374,9 +379,11 @@ private void ValidateResult(void* left, void* right, void* result, [CallerMember
 
         private void ValidateResult(Byte[] left, Byte[] right, Byte[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if ((byte)(~left[0] & right[0]) != result[0])
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -384,19 +391,21 @@ private void ValidateResult(Byte[] left, Byte[] right, Byte[] result, [CallerMem
                 {
                     if ((byte)(~left[i] & right[i]) != result[i])
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Avx2)}.{nameof(Avx2.AndNot)}<Byte>(Vector256<Byte>, Vector256<Byte>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/AndNot.Int16.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/AndNot.Int16.cs
index 316cf11c3bfe..96f27df894c4 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/AndNot.Int16.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/AndNot.Int16.cs
@@ -334,7 +334,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -342,7 +342,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -374,9 +379,11 @@ private void ValidateResult(void* left, void* right, void* result, [CallerMember
 
         private void ValidateResult(Int16[] left, Int16[] right, Int16[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if ((short)(~left[0] & right[0]) != result[0])
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -384,19 +391,21 @@ private void ValidateResult(Int16[] left, Int16[] right, Int16[] result, [Caller
                 {
                     if ((short)(~left[i] & right[i]) != result[i])
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Avx2)}.{nameof(Avx2.AndNot)}<Int16>(Vector256<Int16>, Vector256<Int16>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/AndNot.Int32.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/AndNot.Int32.cs
index 2fe4dbabbaee..fd4e5ac0a017 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/AndNot.Int32.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/AndNot.Int32.cs
@@ -334,7 +334,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -342,7 +342,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -374,9 +379,11 @@ private void ValidateResult(void* left, void* right, void* result, [CallerMember
 
         private void ValidateResult(Int32[] left, Int32[] right, Int32[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if ((int)(~left[0] & right[0]) != result[0])
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -384,19 +391,21 @@ private void ValidateResult(Int32[] left, Int32[] right, Int32[] result, [Caller
                 {
                     if ((int)(~left[i] & right[i]) != result[i])
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Avx2)}.{nameof(Avx2.AndNot)}<Int32>(Vector256<Int32>, Vector256<Int32>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/AndNot.Int64.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/AndNot.Int64.cs
index 8456f6244a79..5337e32743ad 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/AndNot.Int64.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/AndNot.Int64.cs
@@ -334,7 +334,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -342,7 +342,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -374,9 +379,11 @@ private void ValidateResult(void* left, void* right, void* result, [CallerMember
 
         private void ValidateResult(Int64[] left, Int64[] right, Int64[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if ((long)(~left[0] & right[0]) != result[0])
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -384,19 +391,21 @@ private void ValidateResult(Int64[] left, Int64[] right, Int64[] result, [Caller
                 {
                     if ((long)(~left[i] & right[i]) != result[i])
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Avx2)}.{nameof(Avx2.AndNot)}<Int64>(Vector256<Int64>, Vector256<Int64>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/AndNot.SByte.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/AndNot.SByte.cs
index 2eef809fb3f2..dd2e1482de93 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/AndNot.SByte.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/AndNot.SByte.cs
@@ -334,7 +334,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -342,7 +342,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -374,9 +379,11 @@ private void ValidateResult(void* left, void* right, void* result, [CallerMember
 
         private void ValidateResult(SByte[] left, SByte[] right, SByte[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if ((sbyte)(~left[0] & right[0]) != result[0])
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -384,19 +391,21 @@ private void ValidateResult(SByte[] left, SByte[] right, SByte[] result, [Caller
                 {
                     if ((sbyte)(~left[i] & right[i]) != result[i])
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Avx2)}.{nameof(Avx2.AndNot)}<SByte>(Vector256<SByte>, Vector256<SByte>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/AndNot.UInt16.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/AndNot.UInt16.cs
index 26691ea98413..df44e9d04cd8 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/AndNot.UInt16.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/AndNot.UInt16.cs
@@ -334,7 +334,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -342,7 +342,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -374,9 +379,11 @@ private void ValidateResult(void* left, void* right, void* result, [CallerMember
 
         private void ValidateResult(UInt16[] left, UInt16[] right, UInt16[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if ((ushort)(~left[0] & right[0]) != result[0])
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -384,19 +391,21 @@ private void ValidateResult(UInt16[] left, UInt16[] right, UInt16[] result, [Cal
                 {
                     if ((ushort)(~left[i] & right[i]) != result[i])
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Avx2)}.{nameof(Avx2.AndNot)}<UInt16>(Vector256<UInt16>, Vector256<UInt16>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/AndNot.UInt32.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/AndNot.UInt32.cs
index bc5fff119580..152d0cc8e379 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/AndNot.UInt32.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/AndNot.UInt32.cs
@@ -334,7 +334,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -342,7 +342,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -374,9 +379,11 @@ private void ValidateResult(void* left, void* right, void* result, [CallerMember
 
         private void ValidateResult(UInt32[] left, UInt32[] right, UInt32[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if ((uint)(~left[0] & right[0]) != result[0])
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -384,19 +391,21 @@ private void ValidateResult(UInt32[] left, UInt32[] right, UInt32[] result, [Cal
                 {
                     if ((uint)(~left[i] & right[i]) != result[i])
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Avx2)}.{nameof(Avx2.AndNot)}<UInt32>(Vector256<UInt32>, Vector256<UInt32>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/AndNot.UInt64.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/AndNot.UInt64.cs
index 0ba3f09543ee..4e5fee2bdb2b 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/AndNot.UInt64.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/AndNot.UInt64.cs
@@ -334,7 +334,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -342,7 +342,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -374,9 +379,11 @@ private void ValidateResult(void* left, void* right, void* result, [CallerMember
 
         private void ValidateResult(UInt64[] left, UInt64[] right, UInt64[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if ((ulong)(~left[0] & right[0]) != result[0])
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -384,19 +391,21 @@ private void ValidateResult(UInt64[] left, UInt64[] right, UInt64[] result, [Cal
                 {
                     if ((ulong)(~left[i] & right[i]) != result[i])
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Avx2)}.{nameof(Avx2.AndNot)}<UInt64>(Vector256<UInt64>, Vector256<UInt64>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Average.Byte.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Average.Byte.cs
index 3161da713f84..2f98510789e2 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Average.Byte.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Average.Byte.cs
@@ -334,7 +334,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -342,7 +342,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -374,9 +379,11 @@ private void ValidateResult(void* left, void* right, void* result, [CallerMember
 
         private void ValidateResult(Byte[] left, Byte[] right, Byte[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if ((byte)((left[0] + right[0] + 1) >> 1) != result[0])
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -384,19 +391,21 @@ private void ValidateResult(Byte[] left, Byte[] right, Byte[] result, [CallerMem
                 {
                     if ((byte)((left[i] + right[i] + 1) >> 1) != result[i])
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Avx2)}.{nameof(Avx2.Average)}<Byte>(Vector256<Byte>, Vector256<Byte>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Average.UInt16.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Average.UInt16.cs
index 211667158fd9..cd913598d3ae 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Average.UInt16.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Average.UInt16.cs
@@ -334,7 +334,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -342,7 +342,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -374,9 +379,11 @@ private void ValidateResult(void* left, void* right, void* result, [CallerMember
 
         private void ValidateResult(UInt16[] left, UInt16[] right, UInt16[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if ((ushort)((left[0] + right[0] + 1) >> 1) != result[0])
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -384,19 +391,21 @@ private void ValidateResult(UInt16[] left, UInt16[] right, UInt16[] result, [Cal
                 {
                     if ((ushort)((left[i] + right[i] + 1) >> 1) != result[i])
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Avx2)}.{nameof(Avx2.Average)}<UInt16>(Vector256<UInt16>, Vector256<UInt16>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Blend.Int16.1.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Blend.Int16.1.cs
index 089c3662181f..8eaef9846539 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Blend.Int16.1.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Blend.Int16.1.cs
@@ -341,7 +341,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -349,7 +349,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -381,9 +386,11 @@ private void ValidateResult(void* left, void* right, void* result, [CallerMember
 
         private void ValidateResult(Int16[] left, Int16[] right, Int16[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (result[0] != (((1 & (1 << 0)) == 0) ? left[0] : right[0]))
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -391,19 +398,21 @@ private void ValidateResult(Int16[] left, Int16[] right, Int16[] result, [Caller
                 {
                     if (result[i] != ((i < 8) ? (((1 & (1 << i)) == 0) ? left[i] : right[i]) : (((1 & (1 << (i - 8))) == 0) ? left[i] : right[i])))
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Avx2)}.{nameof(Avx2.Blend)}<Int16>(Vector256<Int16>.1, Vector256<Int16>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Blend.Int16.2.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Blend.Int16.2.cs
index 71be7b6f90b5..59b7ae592cd7 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Blend.Int16.2.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Blend.Int16.2.cs
@@ -341,7 +341,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -349,7 +349,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -381,9 +386,11 @@ private void ValidateResult(void* left, void* right, void* result, [CallerMember
 
         private void ValidateResult(Int16[] left, Int16[] right, Int16[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (result[0] != (((2 & (1 << 0)) == 0) ? left[0] : right[0]))
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -391,19 +398,21 @@ private void ValidateResult(Int16[] left, Int16[] right, Int16[] result, [Caller
                 {
                     if (result[i] != ((i < 8) ? (((2 & (1 << i)) == 0) ? left[i] : right[i]) : (((2 & (1 << (i - 8))) == 0) ? left[i] : right[i])))
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Avx2)}.{nameof(Avx2.Blend)}<Int16>(Vector256<Int16>.2, Vector256<Int16>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Blend.Int16.4.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Blend.Int16.4.cs
index 740ab8b9643a..9ef6a619994a 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Blend.Int16.4.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Blend.Int16.4.cs
@@ -341,7 +341,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -349,7 +349,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -381,9 +386,11 @@ private void ValidateResult(void* left, void* right, void* result, [CallerMember
 
         private void ValidateResult(Int16[] left, Int16[] right, Int16[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (result[0] != (((4 & (1 << 0)) == 0) ? left[0] : right[0]))
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -391,19 +398,21 @@ private void ValidateResult(Int16[] left, Int16[] right, Int16[] result, [Caller
                 {
                     if (result[i] != ((i < 8) ? (((4 & (1 << i)) == 0) ? left[i] : right[i]) : (((4 & (1 << (i - 8))) == 0) ? left[i] : right[i])))
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Avx2)}.{nameof(Avx2.Blend)}<Int16>(Vector256<Int16>.4, Vector256<Int16>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Blend.Int16.85.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Blend.Int16.85.cs
index 281a69076b9e..9ec42fadc77c 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Blend.Int16.85.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Blend.Int16.85.cs
@@ -341,7 +341,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -349,7 +349,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -381,9 +386,11 @@ private void ValidateResult(void* left, void* right, void* result, [CallerMember
 
         private void ValidateResult(Int16[] left, Int16[] right, Int16[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (result[0] != (((85 & (1 << 0)) == 0) ? left[0] : right[0]))
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -391,19 +398,21 @@ private void ValidateResult(Int16[] left, Int16[] right, Int16[] result, [Caller
                 {
                     if (result[i] != ((i < 8) ? (((85 & (1 << i)) == 0) ? left[i] : right[i]) : (((85 & (1 << (i - 8))) == 0) ? left[i] : right[i])))
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Avx2)}.{nameof(Avx2.Blend)}<Int16>(Vector256<Int16>.85, Vector256<Int16>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Blend.Int32.1.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Blend.Int32.1.cs
index 318e85ceeceb..05756e122916 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Blend.Int32.1.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Blend.Int32.1.cs
@@ -341,7 +341,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -349,7 +349,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -381,9 +386,11 @@ private void ValidateResult(void* left, void* right, void* result, [CallerMember
 
         private void ValidateResult(Int32[] left, Int32[] right, Int32[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (result[0] != (((1 & (1 << 0)) == 0) ? left[0] : right[0]))
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -391,19 +398,21 @@ private void ValidateResult(Int32[] left, Int32[] right, Int32[] result, [Caller
                 {
                     if (result[i] != (((1 & (1 << i)) == 0) ? left[i] : right[i]))
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Avx2)}.{nameof(Avx2.Blend)}<Int32>(Vector256<Int32>.1, Vector256<Int32>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Blend.Int32.2.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Blend.Int32.2.cs
index 42c4c72e93ab..c0020850c0e1 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Blend.Int32.2.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Blend.Int32.2.cs
@@ -341,7 +341,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -349,7 +349,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -381,9 +386,11 @@ private void ValidateResult(void* left, void* right, void* result, [CallerMember
 
         private void ValidateResult(Int32[] left, Int32[] right, Int32[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (result[0] != (((2 & (1 << 0)) == 0) ? left[0] : right[0]))
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -391,19 +398,21 @@ private void ValidateResult(Int32[] left, Int32[] right, Int32[] result, [Caller
                 {
                     if (result[i] != (((2 & (1 << i)) == 0) ? left[i] : right[i]))
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Avx2)}.{nameof(Avx2.Blend)}<Int32>(Vector256<Int32>.2, Vector256<Int32>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Blend.Int32.4.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Blend.Int32.4.cs
index 5cc2abe1bf50..81d8f3ce6132 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Blend.Int32.4.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Blend.Int32.4.cs
@@ -341,7 +341,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -349,7 +349,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -381,9 +386,11 @@ private void ValidateResult(void* left, void* right, void* result, [CallerMember
 
         private void ValidateResult(Int32[] left, Int32[] right, Int32[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (result[0] != (((4 & (1 << 0)) == 0) ? left[0] : right[0]))
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -391,19 +398,21 @@ private void ValidateResult(Int32[] left, Int32[] right, Int32[] result, [Caller
                 {
                     if (result[i] != (((4 & (1 << i)) == 0) ? left[i] : right[i]))
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Avx2)}.{nameof(Avx2.Blend)}<Int32>(Vector256<Int32>.4, Vector256<Int32>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Blend.Int32.85.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Blend.Int32.85.cs
index 5e24848c84bb..2f497c31ed8f 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Blend.Int32.85.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Blend.Int32.85.cs
@@ -341,7 +341,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -349,7 +349,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -381,9 +386,11 @@ private void ValidateResult(void* left, void* right, void* result, [CallerMember
 
         private void ValidateResult(Int32[] left, Int32[] right, Int32[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (result[0] != (((85 & (1 << 0)) == 0) ? left[0] : right[0]))
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -391,19 +398,21 @@ private void ValidateResult(Int32[] left, Int32[] right, Int32[] result, [Caller
                 {
                     if (result[i] != (((85 & (1 << i)) == 0) ? left[i] : right[i]))
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Avx2)}.{nameof(Avx2.Blend)}<Int32>(Vector256<Int32>.85, Vector256<Int32>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Blend.UInt16.1.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Blend.UInt16.1.cs
index 66029bb7362d..92cd5a3d50eb 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Blend.UInt16.1.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Blend.UInt16.1.cs
@@ -341,7 +341,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -349,7 +349,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -381,9 +386,11 @@ private void ValidateResult(void* left, void* right, void* result, [CallerMember
 
         private void ValidateResult(UInt16[] left, UInt16[] right, UInt16[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (result[0] != (((1 & (1 << 0)) == 0) ? left[0] : right[0]))
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -391,19 +398,21 @@ private void ValidateResult(UInt16[] left, UInt16[] right, UInt16[] result, [Cal
                 {
                     if (result[i] != ((i < 8) ? (((1 & (1 << i)) == 0) ? left[i] : right[i]) : (((1 & (1 << (i - 8))) == 0) ? left[i] : right[i])))
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Avx2)}.{nameof(Avx2.Blend)}<UInt16>(Vector256<UInt16>.1, Vector256<UInt16>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Blend.UInt16.2.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Blend.UInt16.2.cs
index 368e4e1e6ff3..00d50b267313 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Blend.UInt16.2.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Blend.UInt16.2.cs
@@ -341,7 +341,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -349,7 +349,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -381,9 +386,11 @@ private void ValidateResult(void* left, void* right, void* result, [CallerMember
 
         private void ValidateResult(UInt16[] left, UInt16[] right, UInt16[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (result[0] != (((2 & (1 << 0)) == 0) ? left[0] : right[0]))
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -391,19 +398,21 @@ private void ValidateResult(UInt16[] left, UInt16[] right, UInt16[] result, [Cal
                 {
                     if (result[i] != ((i < 8) ? (((2 & (1 << i)) == 0) ? left[i] : right[i]) : (((2 & (1 << (i - 8))) == 0) ? left[i] : right[i])))
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Avx2)}.{nameof(Avx2.Blend)}<UInt16>(Vector256<UInt16>.2, Vector256<UInt16>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Blend.UInt16.4.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Blend.UInt16.4.cs
index 4f216849f440..5c1089b98d2d 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Blend.UInt16.4.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Blend.UInt16.4.cs
@@ -341,7 +341,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -349,7 +349,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -381,9 +386,11 @@ private void ValidateResult(void* left, void* right, void* result, [CallerMember
 
         private void ValidateResult(UInt16[] left, UInt16[] right, UInt16[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (result[0] != (((4 & (1 << 0)) == 0) ? left[0] : right[0]))
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -391,19 +398,21 @@ private void ValidateResult(UInt16[] left, UInt16[] right, UInt16[] result, [Cal
                 {
                     if (result[i] != ((i < 8) ? (((4 & (1 << i)) == 0) ? left[i] : right[i]) : (((4 & (1 << (i - 8))) == 0) ? left[i] : right[i])))
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Avx2)}.{nameof(Avx2.Blend)}<UInt16>(Vector256<UInt16>.4, Vector256<UInt16>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Blend.UInt16.85.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Blend.UInt16.85.cs
index a9622cb6659e..b7adac5a4326 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Blend.UInt16.85.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Blend.UInt16.85.cs
@@ -341,7 +341,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -349,7 +349,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -381,9 +386,11 @@ private void ValidateResult(void* left, void* right, void* result, [CallerMember
 
         private void ValidateResult(UInt16[] left, UInt16[] right, UInt16[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (result[0] != (((85 & (1 << 0)) == 0) ? left[0] : right[0]))
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -391,19 +398,21 @@ private void ValidateResult(UInt16[] left, UInt16[] right, UInt16[] result, [Cal
                 {
                     if (result[i] != ((i < 8) ? (((85 & (1 << i)) == 0) ? left[i] : right[i]) : (((85 & (1 << (i - 8))) == 0) ? left[i] : right[i])))
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Avx2)}.{nameof(Avx2.Blend)}<UInt16>(Vector256<UInt16>.85, Vector256<UInt16>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Blend.UInt32.1.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Blend.UInt32.1.cs
index 9748dbbd4262..429f2ecbafc3 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Blend.UInt32.1.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Blend.UInt32.1.cs
@@ -341,7 +341,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -349,7 +349,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -381,9 +386,11 @@ private void ValidateResult(void* left, void* right, void* result, [CallerMember
 
         private void ValidateResult(UInt32[] left, UInt32[] right, UInt32[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (result[0] != (((1 & (1 << 0)) == 0) ? left[0] : right[0]))
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -391,19 +398,21 @@ private void ValidateResult(UInt32[] left, UInt32[] right, UInt32[] result, [Cal
                 {
                     if (result[i] != (((1 & (1 << i)) == 0) ? left[i] : right[i]))
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Avx2)}.{nameof(Avx2.Blend)}<UInt32>(Vector256<UInt32>.1, Vector256<UInt32>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Blend.UInt32.2.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Blend.UInt32.2.cs
index 41f3997fea29..047a50ec5a6c 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Blend.UInt32.2.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Blend.UInt32.2.cs
@@ -341,7 +341,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -349,7 +349,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -381,9 +386,11 @@ private void ValidateResult(void* left, void* right, void* result, [CallerMember
 
         private void ValidateResult(UInt32[] left, UInt32[] right, UInt32[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (result[0] != (((2 & (1 << 0)) == 0) ? left[0] : right[0]))
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -391,19 +398,21 @@ private void ValidateResult(UInt32[] left, UInt32[] right, UInt32[] result, [Cal
                 {
                     if (result[i] != (((2 & (1 << i)) == 0) ? left[i] : right[i]))
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Avx2)}.{nameof(Avx2.Blend)}<UInt32>(Vector256<UInt32>.2, Vector256<UInt32>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Blend.UInt32.4.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Blend.UInt32.4.cs
index 6c5fdc0c89f4..1a4e1bf2c850 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Blend.UInt32.4.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Blend.UInt32.4.cs
@@ -341,7 +341,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -349,7 +349,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -381,9 +386,11 @@ private void ValidateResult(void* left, void* right, void* result, [CallerMember
 
         private void ValidateResult(UInt32[] left, UInt32[] right, UInt32[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (result[0] != (((4 & (1 << 0)) == 0) ? left[0] : right[0]))
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -391,19 +398,21 @@ private void ValidateResult(UInt32[] left, UInt32[] right, UInt32[] result, [Cal
                 {
                     if (result[i] != (((4 & (1 << i)) == 0) ? left[i] : right[i]))
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Avx2)}.{nameof(Avx2.Blend)}<UInt32>(Vector256<UInt32>.4, Vector256<UInt32>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Blend.UInt32.85.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Blend.UInt32.85.cs
index 5058fb800107..41478263e8d4 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Blend.UInt32.85.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Blend.UInt32.85.cs
@@ -341,7 +341,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -349,7 +349,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -381,9 +386,11 @@ private void ValidateResult(void* left, void* right, void* result, [CallerMember
 
         private void ValidateResult(UInt32[] left, UInt32[] right, UInt32[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (result[0] != (((85 & (1 << 0)) == 0) ? left[0] : right[0]))
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -391,19 +398,21 @@ private void ValidateResult(UInt32[] left, UInt32[] right, UInt32[] result, [Cal
                 {
                     if (result[i] != (((85 & (1 << i)) == 0) ? left[i] : right[i]))
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Avx2)}.{nameof(Avx2.Blend)}<UInt32>(Vector256<UInt32>.85, Vector256<UInt32>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/BlendVariable.Byte.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/BlendVariable.Byte.cs
index 2d997c3dde2a..4b1fa7967cee 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/BlendVariable.Byte.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/BlendVariable.Byte.cs
@@ -356,7 +356,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -364,7 +364,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -400,9 +405,11 @@ private void ValidateResult(void* firstOp, void* secondOp, void* thirdOp, void*
 
         private void ValidateResult(Byte[] firstOp, Byte[] secondOp, Byte[] thirdOp, Byte[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (((thirdOp[0] >> 7) & 1) == 1 ? secondOp[0] != result[0] : firstOp[0] != result[0])
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -410,13 +417,13 @@ private void ValidateResult(Byte[] firstOp, Byte[] secondOp, Byte[] thirdOp, Byt
                 {
                     if (((thirdOp[i] >> 7) & 1) == 1 ? secondOp[i] != result[i] : firstOp[i] != result[i])
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Avx2)}.{nameof(Avx2.BlendVariable)}<Byte>(Vector256<Byte>, Vector256<Byte>, Vector256<Byte>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"   firstOp: ({string.Join(", ", firstOp)})");
@@ -424,6 +431,8 @@ private void ValidateResult(Byte[] firstOp, Byte[] secondOp, Byte[] thirdOp, Byt
                 TestLibrary.TestFramework.LogInformation($"   thirdOp: ({string.Join(", ", thirdOp)})");
                 TestLibrary.TestFramework.LogInformation($"    result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/BlendVariable.Int16.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/BlendVariable.Int16.cs
index ca5158287d0b..a099f4a89b92 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/BlendVariable.Int16.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/BlendVariable.Int16.cs
@@ -356,7 +356,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -364,7 +364,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -400,9 +405,11 @@ private void ValidateResult(void* firstOp, void* secondOp, void* thirdOp, void*
 
         private void ValidateResult(Int16[] firstOp, Int16[] secondOp, Int16[] thirdOp, Int16[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if ((thirdOp[0] != 0) ? secondOp[0] != result[0] : firstOp[0] != result[0])
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -410,13 +417,13 @@ private void ValidateResult(Int16[] firstOp, Int16[] secondOp, Int16[] thirdOp,
                 {
                     if ((thirdOp[i] != 0) ? secondOp[i] != result[i] : firstOp[i] != result[i])
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Avx2)}.{nameof(Avx2.BlendVariable)}<Int16>(Vector256<Int16>, Vector256<Int16>, Vector256<Int16>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"   firstOp: ({string.Join(", ", firstOp)})");
@@ -424,6 +431,8 @@ private void ValidateResult(Int16[] firstOp, Int16[] secondOp, Int16[] thirdOp,
                 TestLibrary.TestFramework.LogInformation($"   thirdOp: ({string.Join(", ", thirdOp)})");
                 TestLibrary.TestFramework.LogInformation($"    result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/BlendVariable.Int32.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/BlendVariable.Int32.cs
index 098f31040bad..63dbc6a1d5e7 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/BlendVariable.Int32.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/BlendVariable.Int32.cs
@@ -356,7 +356,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -364,7 +364,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -400,9 +405,11 @@ private void ValidateResult(void* firstOp, void* secondOp, void* thirdOp, void*
 
         private void ValidateResult(Int32[] firstOp, Int32[] secondOp, Int32[] thirdOp, Int32[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if ((thirdOp[0] != 0) ? secondOp[0] != result[0] : firstOp[0] != result[0])
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -410,13 +417,13 @@ private void ValidateResult(Int32[] firstOp, Int32[] secondOp, Int32[] thirdOp,
                 {
                     if ((thirdOp[i] != 0) ? secondOp[i] != result[i] : firstOp[i] != result[i])
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Avx2)}.{nameof(Avx2.BlendVariable)}<Int32>(Vector256<Int32>, Vector256<Int32>, Vector256<Int32>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"   firstOp: ({string.Join(", ", firstOp)})");
@@ -424,6 +431,8 @@ private void ValidateResult(Int32[] firstOp, Int32[] secondOp, Int32[] thirdOp,
                 TestLibrary.TestFramework.LogInformation($"   thirdOp: ({string.Join(", ", thirdOp)})");
                 TestLibrary.TestFramework.LogInformation($"    result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/BlendVariable.Int64.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/BlendVariable.Int64.cs
index 1b545facfd22..d91e83e957af 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/BlendVariable.Int64.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/BlendVariable.Int64.cs
@@ -356,7 +356,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -364,7 +364,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -400,9 +405,11 @@ private void ValidateResult(void* firstOp, void* secondOp, void* thirdOp, void*
 
         private void ValidateResult(Int64[] firstOp, Int64[] secondOp, Int64[] thirdOp, Int64[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if ((thirdOp[0] != 0) ? secondOp[0] != result[0] : firstOp[0] != result[0])
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -410,13 +417,13 @@ private void ValidateResult(Int64[] firstOp, Int64[] secondOp, Int64[] thirdOp,
                 {
                     if ((thirdOp[i] != 0) ? secondOp[i] != result[i] : firstOp[i] != result[i])
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Avx2)}.{nameof(Avx2.BlendVariable)}<Int64>(Vector256<Int64>, Vector256<Int64>, Vector256<Int64>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"   firstOp: ({string.Join(", ", firstOp)})");
@@ -424,6 +431,8 @@ private void ValidateResult(Int64[] firstOp, Int64[] secondOp, Int64[] thirdOp,
                 TestLibrary.TestFramework.LogInformation($"   thirdOp: ({string.Join(", ", thirdOp)})");
                 TestLibrary.TestFramework.LogInformation($"    result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/BlendVariable.SByte.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/BlendVariable.SByte.cs
index cbe879db0162..37c0ef595185 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/BlendVariable.SByte.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/BlendVariable.SByte.cs
@@ -356,7 +356,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -364,7 +364,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -400,9 +405,11 @@ private void ValidateResult(void* firstOp, void* secondOp, void* thirdOp, void*
 
         private void ValidateResult(SByte[] firstOp, SByte[] secondOp, SByte[] thirdOp, SByte[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (((thirdOp[0] >> 7) & 1) == 1 ? secondOp[0] != result[0] : firstOp[0] != result[0])
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -410,13 +417,13 @@ private void ValidateResult(SByte[] firstOp, SByte[] secondOp, SByte[] thirdOp,
                 {
                     if (((thirdOp[i] >> 7) & 1) == 1 ? secondOp[i] != result[i] : firstOp[i] != result[i])
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Avx2)}.{nameof(Avx2.BlendVariable)}<SByte>(Vector256<SByte>, Vector256<SByte>, Vector256<SByte>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"   firstOp: ({string.Join(", ", firstOp)})");
@@ -424,6 +431,8 @@ private void ValidateResult(SByte[] firstOp, SByte[] secondOp, SByte[] thirdOp,
                 TestLibrary.TestFramework.LogInformation($"   thirdOp: ({string.Join(", ", thirdOp)})");
                 TestLibrary.TestFramework.LogInformation($"    result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/BlendVariable.UInt16.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/BlendVariable.UInt16.cs
index 6487d803a293..7f840f3af854 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/BlendVariable.UInt16.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/BlendVariable.UInt16.cs
@@ -356,7 +356,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -364,7 +364,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -400,9 +405,11 @@ private void ValidateResult(void* firstOp, void* secondOp, void* thirdOp, void*
 
         private void ValidateResult(UInt16[] firstOp, UInt16[] secondOp, UInt16[] thirdOp, UInt16[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if ((thirdOp[0] != 0) ? secondOp[0] != result[0] : firstOp[0] != result[0])
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -410,13 +417,13 @@ private void ValidateResult(UInt16[] firstOp, UInt16[] secondOp, UInt16[] thirdO
                 {
                     if ((thirdOp[i] != 0) ? secondOp[i] != result[i] : firstOp[i] != result[i])
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Avx2)}.{nameof(Avx2.BlendVariable)}<UInt16>(Vector256<UInt16>, Vector256<UInt16>, Vector256<UInt16>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"   firstOp: ({string.Join(", ", firstOp)})");
@@ -424,6 +431,8 @@ private void ValidateResult(UInt16[] firstOp, UInt16[] secondOp, UInt16[] thirdO
                 TestLibrary.TestFramework.LogInformation($"   thirdOp: ({string.Join(", ", thirdOp)})");
                 TestLibrary.TestFramework.LogInformation($"    result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/BlendVariable.UInt32.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/BlendVariable.UInt32.cs
index c07d890490e4..a192e9975db9 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/BlendVariable.UInt32.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/BlendVariable.UInt32.cs
@@ -356,7 +356,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -364,7 +364,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -400,9 +405,11 @@ private void ValidateResult(void* firstOp, void* secondOp, void* thirdOp, void*
 
         private void ValidateResult(UInt32[] firstOp, UInt32[] secondOp, UInt32[] thirdOp, UInt32[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if ((thirdOp[0] != 0) ? secondOp[0] != result[0] : firstOp[0] != result[0])
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -410,13 +417,13 @@ private void ValidateResult(UInt32[] firstOp, UInt32[] secondOp, UInt32[] thirdO
                 {
                     if ((thirdOp[i] != 0) ? secondOp[i] != result[i] : firstOp[i] != result[i])
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Avx2)}.{nameof(Avx2.BlendVariable)}<UInt32>(Vector256<UInt32>, Vector256<UInt32>, Vector256<UInt32>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"   firstOp: ({string.Join(", ", firstOp)})");
@@ -424,6 +431,8 @@ private void ValidateResult(UInt32[] firstOp, UInt32[] secondOp, UInt32[] thirdO
                 TestLibrary.TestFramework.LogInformation($"   thirdOp: ({string.Join(", ", thirdOp)})");
                 TestLibrary.TestFramework.LogInformation($"    result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/BlendVariable.UInt64.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/BlendVariable.UInt64.cs
index f85c17bf4013..b82b79c1e913 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/BlendVariable.UInt64.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/BlendVariable.UInt64.cs
@@ -356,7 +356,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -364,7 +364,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -400,9 +405,11 @@ private void ValidateResult(void* firstOp, void* secondOp, void* thirdOp, void*
 
         private void ValidateResult(UInt64[] firstOp, UInt64[] secondOp, UInt64[] thirdOp, UInt64[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if ((thirdOp[0] != 0) ? secondOp[0] != result[0] : firstOp[0] != result[0])
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -410,13 +417,13 @@ private void ValidateResult(UInt64[] firstOp, UInt64[] secondOp, UInt64[] thirdO
                 {
                     if ((thirdOp[i] != 0) ? secondOp[i] != result[i] : firstOp[i] != result[i])
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Avx2)}.{nameof(Avx2.BlendVariable)}<UInt64>(Vector256<UInt64>, Vector256<UInt64>, Vector256<UInt64>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"   firstOp: ({string.Join(", ", firstOp)})");
@@ -424,6 +431,8 @@ private void ValidateResult(UInt64[] firstOp, UInt64[] secondOp, UInt64[] thirdO
                 TestLibrary.TestFramework.LogInformation($"   thirdOp: ({string.Join(", ", thirdOp)})");
                 TestLibrary.TestFramework.LogInformation($"    result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/BroadcastScalarToVector128.Byte.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/BroadcastScalarToVector128.Byte.cs
index c138eb3be047..f4040e562ed5 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/BroadcastScalarToVector128.Byte.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/BroadcastScalarToVector128.Byte.cs
@@ -312,7 +312,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -320,7 +320,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -348,9 +353,11 @@ private void ValidateResult(void* firstOp, void* result, [CallerMemberName] stri
 
         private void ValidateResult(Byte[] firstOp, Byte[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (firstOp[0] != result[0])
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -358,18 +365,20 @@ private void ValidateResult(Byte[] firstOp, Byte[] result, [CallerMemberName] st
                 {
                     if ((firstOp[0] != result[i]))
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Avx2)}.{nameof(Avx2.BroadcastScalarToVector128)}<Byte>(Vector128<Byte>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"  firstOp: ({string.Join(", ", firstOp)})");
                 TestLibrary.TestFramework.LogInformation($"   result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/BroadcastScalarToVector128.Double.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/BroadcastScalarToVector128.Double.cs
index aafaabd6483f..96eb1613a290 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/BroadcastScalarToVector128.Double.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/BroadcastScalarToVector128.Double.cs
@@ -312,7 +312,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -320,7 +320,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -348,9 +353,11 @@ private void ValidateResult(void* firstOp, void* result, [CallerMemberName] stri
 
         private void ValidateResult(Double[] firstOp, Double[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (BitConverter.DoubleToInt64Bits(firstOp[0]) != BitConverter.DoubleToInt64Bits(result[0]))
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -358,18 +365,20 @@ private void ValidateResult(Double[] firstOp, Double[] result, [CallerMemberName
                 {
                     if ((BitConverter.DoubleToInt64Bits(firstOp[0]) != BitConverter.DoubleToInt64Bits(result[i])))
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Avx2)}.{nameof(Avx2.BroadcastScalarToVector128)}<Double>(Vector128<Double>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"  firstOp: ({string.Join(", ", firstOp)})");
                 TestLibrary.TestFramework.LogInformation($"   result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/BroadcastScalarToVector128.Int16.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/BroadcastScalarToVector128.Int16.cs
index 69a62d273635..6d7624b60194 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/BroadcastScalarToVector128.Int16.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/BroadcastScalarToVector128.Int16.cs
@@ -312,7 +312,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -320,7 +320,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -348,9 +353,11 @@ private void ValidateResult(void* firstOp, void* result, [CallerMemberName] stri
 
         private void ValidateResult(Int16[] firstOp, Int16[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (firstOp[0] != result[0])
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -358,18 +365,20 @@ private void ValidateResult(Int16[] firstOp, Int16[] result, [CallerMemberName]
                 {
                     if ((firstOp[0] != result[i]))
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Avx2)}.{nameof(Avx2.BroadcastScalarToVector128)}<Int16>(Vector128<Int16>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"  firstOp: ({string.Join(", ", firstOp)})");
                 TestLibrary.TestFramework.LogInformation($"   result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/BroadcastScalarToVector128.Int32.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/BroadcastScalarToVector128.Int32.cs
index a4b4599b28a6..4613c2e75488 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/BroadcastScalarToVector128.Int32.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/BroadcastScalarToVector128.Int32.cs
@@ -312,7 +312,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -320,7 +320,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -348,9 +353,11 @@ private void ValidateResult(void* firstOp, void* result, [CallerMemberName] stri
 
         private void ValidateResult(Int32[] firstOp, Int32[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (firstOp[0] != result[0])
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -358,18 +365,20 @@ private void ValidateResult(Int32[] firstOp, Int32[] result, [CallerMemberName]
                 {
                     if ((firstOp[0] != result[i]))
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Avx2)}.{nameof(Avx2.BroadcastScalarToVector128)}<Int32>(Vector128<Int32>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"  firstOp: ({string.Join(", ", firstOp)})");
                 TestLibrary.TestFramework.LogInformation($"   result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/BroadcastScalarToVector128.Int64.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/BroadcastScalarToVector128.Int64.cs
index 5f3388553438..0aa3890286ce 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/BroadcastScalarToVector128.Int64.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/BroadcastScalarToVector128.Int64.cs
@@ -312,7 +312,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -320,7 +320,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -348,9 +353,11 @@ private void ValidateResult(void* firstOp, void* result, [CallerMemberName] stri
 
         private void ValidateResult(Int64[] firstOp, Int64[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (firstOp[0] != result[0])
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -358,18 +365,20 @@ private void ValidateResult(Int64[] firstOp, Int64[] result, [CallerMemberName]
                 {
                     if ((firstOp[0] != result[i]))
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Avx2)}.{nameof(Avx2.BroadcastScalarToVector128)}<Int64>(Vector128<Int64>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"  firstOp: ({string.Join(", ", firstOp)})");
                 TestLibrary.TestFramework.LogInformation($"   result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/BroadcastScalarToVector128.SByte.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/BroadcastScalarToVector128.SByte.cs
index 35a87ab072c1..7e8913e1801b 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/BroadcastScalarToVector128.SByte.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/BroadcastScalarToVector128.SByte.cs
@@ -312,7 +312,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -320,7 +320,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -348,9 +353,11 @@ private void ValidateResult(void* firstOp, void* result, [CallerMemberName] stri
 
         private void ValidateResult(SByte[] firstOp, SByte[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (firstOp[0] != result[0])
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -358,18 +365,20 @@ private void ValidateResult(SByte[] firstOp, SByte[] result, [CallerMemberName]
                 {
                     if ((firstOp[0] != result[i]))
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Avx2)}.{nameof(Avx2.BroadcastScalarToVector128)}<SByte>(Vector128<SByte>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"  firstOp: ({string.Join(", ", firstOp)})");
                 TestLibrary.TestFramework.LogInformation($"   result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/BroadcastScalarToVector128.Single.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/BroadcastScalarToVector128.Single.cs
index 76adc44af71f..7ec0e4aae490 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/BroadcastScalarToVector128.Single.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/BroadcastScalarToVector128.Single.cs
@@ -312,7 +312,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -320,7 +320,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -348,9 +353,11 @@ private void ValidateResult(void* firstOp, void* result, [CallerMemberName] stri
 
         private void ValidateResult(Single[] firstOp, Single[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (BitConverter.SingleToInt32Bits(firstOp[0]) != BitConverter.SingleToInt32Bits(result[0]))
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -358,18 +365,20 @@ private void ValidateResult(Single[] firstOp, Single[] result, [CallerMemberName
                 {
                     if ((BitConverter.SingleToInt32Bits(firstOp[0]) != BitConverter.SingleToInt32Bits(result[i])))
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Avx2)}.{nameof(Avx2.BroadcastScalarToVector128)}<Single>(Vector128<Single>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"  firstOp: ({string.Join(", ", firstOp)})");
                 TestLibrary.TestFramework.LogInformation($"   result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/BroadcastScalarToVector128.UInt16.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/BroadcastScalarToVector128.UInt16.cs
index 5be62b12ce1e..adf87076c17a 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/BroadcastScalarToVector128.UInt16.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/BroadcastScalarToVector128.UInt16.cs
@@ -312,7 +312,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -320,7 +320,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -348,9 +353,11 @@ private void ValidateResult(void* firstOp, void* result, [CallerMemberName] stri
 
         private void ValidateResult(UInt16[] firstOp, UInt16[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (firstOp[0] != result[0])
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -358,18 +365,20 @@ private void ValidateResult(UInt16[] firstOp, UInt16[] result, [CallerMemberName
                 {
                     if ((firstOp[0] != result[i]))
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Avx2)}.{nameof(Avx2.BroadcastScalarToVector128)}<UInt16>(Vector128<UInt16>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"  firstOp: ({string.Join(", ", firstOp)})");
                 TestLibrary.TestFramework.LogInformation($"   result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/BroadcastScalarToVector128.UInt32.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/BroadcastScalarToVector128.UInt32.cs
index c263a2d0a679..b4c2bcd1a476 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/BroadcastScalarToVector128.UInt32.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/BroadcastScalarToVector128.UInt32.cs
@@ -312,7 +312,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -320,7 +320,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -348,9 +353,11 @@ private void ValidateResult(void* firstOp, void* result, [CallerMemberName] stri
 
         private void ValidateResult(UInt32[] firstOp, UInt32[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (firstOp[0] != result[0])
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -358,18 +365,20 @@ private void ValidateResult(UInt32[] firstOp, UInt32[] result, [CallerMemberName
                 {
                     if ((firstOp[0] != result[i]))
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Avx2)}.{nameof(Avx2.BroadcastScalarToVector128)}<UInt32>(Vector128<UInt32>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"  firstOp: ({string.Join(", ", firstOp)})");
                 TestLibrary.TestFramework.LogInformation($"   result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/BroadcastScalarToVector128.UInt64.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/BroadcastScalarToVector128.UInt64.cs
index 8053140350b3..8c66d7be3571 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/BroadcastScalarToVector128.UInt64.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/BroadcastScalarToVector128.UInt64.cs
@@ -312,7 +312,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -320,7 +320,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -348,9 +353,11 @@ private void ValidateResult(void* firstOp, void* result, [CallerMemberName] stri
 
         private void ValidateResult(UInt64[] firstOp, UInt64[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (firstOp[0] != result[0])
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -358,18 +365,20 @@ private void ValidateResult(UInt64[] firstOp, UInt64[] result, [CallerMemberName
                 {
                     if ((firstOp[0] != result[i]))
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Avx2)}.{nameof(Avx2.BroadcastScalarToVector128)}<UInt64>(Vector128<UInt64>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"  firstOp: ({string.Join(", ", firstOp)})");
                 TestLibrary.TestFramework.LogInformation($"   result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/BroadcastScalarToVector256.Byte.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/BroadcastScalarToVector256.Byte.cs
index 44306695a597..2c12caeb4bc0 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/BroadcastScalarToVector256.Byte.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/BroadcastScalarToVector256.Byte.cs
@@ -312,7 +312,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -320,7 +320,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -348,9 +353,11 @@ private void ValidateResult(void* firstOp, void* result, [CallerMemberName] stri
 
         private void ValidateResult(Byte[] firstOp, Byte[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (firstOp[0] != result[0])
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -358,18 +365,20 @@ private void ValidateResult(Byte[] firstOp, Byte[] result, [CallerMemberName] st
                 {
                     if ((firstOp[0] != result[i]))
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Avx2)}.{nameof(Avx2.BroadcastScalarToVector256)}<Byte>(Vector128<Byte>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"  firstOp: ({string.Join(", ", firstOp)})");
                 TestLibrary.TestFramework.LogInformation($"   result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/BroadcastScalarToVector256.Double.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/BroadcastScalarToVector256.Double.cs
index a16e088706a3..e45764903d9a 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/BroadcastScalarToVector256.Double.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/BroadcastScalarToVector256.Double.cs
@@ -312,7 +312,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -320,7 +320,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -348,9 +353,11 @@ private void ValidateResult(void* firstOp, void* result, [CallerMemberName] stri
 
         private void ValidateResult(Double[] firstOp, Double[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (BitConverter.DoubleToInt64Bits(firstOp[0]) != BitConverter.DoubleToInt64Bits(result[0]))
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -358,18 +365,20 @@ private void ValidateResult(Double[] firstOp, Double[] result, [CallerMemberName
                 {
                     if ((BitConverter.DoubleToInt64Bits(firstOp[0]) != BitConverter.DoubleToInt64Bits(result[i])))
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Avx2)}.{nameof(Avx2.BroadcastScalarToVector256)}<Double>(Vector128<Double>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"  firstOp: ({string.Join(", ", firstOp)})");
                 TestLibrary.TestFramework.LogInformation($"   result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/BroadcastScalarToVector256.Int16.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/BroadcastScalarToVector256.Int16.cs
index 5a3e1ea69443..ca75f43c0e86 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/BroadcastScalarToVector256.Int16.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/BroadcastScalarToVector256.Int16.cs
@@ -312,7 +312,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -320,7 +320,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -348,9 +353,11 @@ private void ValidateResult(void* firstOp, void* result, [CallerMemberName] stri
 
         private void ValidateResult(Int16[] firstOp, Int16[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (firstOp[0] != result[0])
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -358,18 +365,20 @@ private void ValidateResult(Int16[] firstOp, Int16[] result, [CallerMemberName]
                 {
                     if ((firstOp[0] != result[i]))
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Avx2)}.{nameof(Avx2.BroadcastScalarToVector256)}<Int16>(Vector128<Int16>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"  firstOp: ({string.Join(", ", firstOp)})");
                 TestLibrary.TestFramework.LogInformation($"   result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/BroadcastScalarToVector256.Int32.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/BroadcastScalarToVector256.Int32.cs
index a7a2573b0a8f..299780fa72b7 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/BroadcastScalarToVector256.Int32.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/BroadcastScalarToVector256.Int32.cs
@@ -312,7 +312,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -320,7 +320,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -348,9 +353,11 @@ private void ValidateResult(void* firstOp, void* result, [CallerMemberName] stri
 
         private void ValidateResult(Int32[] firstOp, Int32[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (firstOp[0] != result[0])
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -358,18 +365,20 @@ private void ValidateResult(Int32[] firstOp, Int32[] result, [CallerMemberName]
                 {
                     if ((firstOp[0] != result[i]))
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Avx2)}.{nameof(Avx2.BroadcastScalarToVector256)}<Int32>(Vector128<Int32>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"  firstOp: ({string.Join(", ", firstOp)})");
                 TestLibrary.TestFramework.LogInformation($"   result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/BroadcastScalarToVector256.Int64.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/BroadcastScalarToVector256.Int64.cs
index ed0e1c5c0191..895cbf1a09f4 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/BroadcastScalarToVector256.Int64.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/BroadcastScalarToVector256.Int64.cs
@@ -312,7 +312,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -320,7 +320,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -348,9 +353,11 @@ private void ValidateResult(void* firstOp, void* result, [CallerMemberName] stri
 
         private void ValidateResult(Int64[] firstOp, Int64[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (firstOp[0] != result[0])
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -358,18 +365,20 @@ private void ValidateResult(Int64[] firstOp, Int64[] result, [CallerMemberName]
                 {
                     if ((firstOp[0] != result[i]))
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Avx2)}.{nameof(Avx2.BroadcastScalarToVector256)}<Int64>(Vector128<Int64>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"  firstOp: ({string.Join(", ", firstOp)})");
                 TestLibrary.TestFramework.LogInformation($"   result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/BroadcastScalarToVector256.SByte.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/BroadcastScalarToVector256.SByte.cs
index 51434c3cf669..e95a97575192 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/BroadcastScalarToVector256.SByte.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/BroadcastScalarToVector256.SByte.cs
@@ -312,7 +312,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -320,7 +320,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -348,9 +353,11 @@ private void ValidateResult(void* firstOp, void* result, [CallerMemberName] stri
 
         private void ValidateResult(SByte[] firstOp, SByte[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (firstOp[0] != result[0])
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -358,18 +365,20 @@ private void ValidateResult(SByte[] firstOp, SByte[] result, [CallerMemberName]
                 {
                     if ((firstOp[0] != result[i]))
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Avx2)}.{nameof(Avx2.BroadcastScalarToVector256)}<SByte>(Vector128<SByte>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"  firstOp: ({string.Join(", ", firstOp)})");
                 TestLibrary.TestFramework.LogInformation($"   result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/BroadcastScalarToVector256.Single.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/BroadcastScalarToVector256.Single.cs
index f5203e64b671..352208efd70c 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/BroadcastScalarToVector256.Single.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/BroadcastScalarToVector256.Single.cs
@@ -312,7 +312,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -320,7 +320,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -348,9 +353,11 @@ private void ValidateResult(void* firstOp, void* result, [CallerMemberName] stri
 
         private void ValidateResult(Single[] firstOp, Single[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (BitConverter.SingleToInt32Bits(firstOp[0]) != BitConverter.SingleToInt32Bits(result[0]))
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -358,18 +365,20 @@ private void ValidateResult(Single[] firstOp, Single[] result, [CallerMemberName
                 {
                     if ((BitConverter.SingleToInt32Bits(firstOp[0]) != BitConverter.SingleToInt32Bits(result[i])))
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Avx2)}.{nameof(Avx2.BroadcastScalarToVector256)}<Single>(Vector128<Single>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"  firstOp: ({string.Join(", ", firstOp)})");
                 TestLibrary.TestFramework.LogInformation($"   result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/BroadcastScalarToVector256.UInt16.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/BroadcastScalarToVector256.UInt16.cs
index 5b38c981e2d5..4bdd227cffac 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/BroadcastScalarToVector256.UInt16.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/BroadcastScalarToVector256.UInt16.cs
@@ -312,7 +312,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -320,7 +320,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -348,9 +353,11 @@ private void ValidateResult(void* firstOp, void* result, [CallerMemberName] stri
 
         private void ValidateResult(UInt16[] firstOp, UInt16[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (firstOp[0] != result[0])
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -358,18 +365,20 @@ private void ValidateResult(UInt16[] firstOp, UInt16[] result, [CallerMemberName
                 {
                     if ((firstOp[0] != result[i]))
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Avx2)}.{nameof(Avx2.BroadcastScalarToVector256)}<UInt16>(Vector128<UInt16>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"  firstOp: ({string.Join(", ", firstOp)})");
                 TestLibrary.TestFramework.LogInformation($"   result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/BroadcastScalarToVector256.UInt32.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/BroadcastScalarToVector256.UInt32.cs
index 1ace07b774a7..eb25d89b28d9 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/BroadcastScalarToVector256.UInt32.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/BroadcastScalarToVector256.UInt32.cs
@@ -312,7 +312,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -320,7 +320,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -348,9 +353,11 @@ private void ValidateResult(void* firstOp, void* result, [CallerMemberName] stri
 
         private void ValidateResult(UInt32[] firstOp, UInt32[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (firstOp[0] != result[0])
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -358,18 +365,20 @@ private void ValidateResult(UInt32[] firstOp, UInt32[] result, [CallerMemberName
                 {
                     if ((firstOp[0] != result[i]))
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Avx2)}.{nameof(Avx2.BroadcastScalarToVector256)}<UInt32>(Vector128<UInt32>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"  firstOp: ({string.Join(", ", firstOp)})");
                 TestLibrary.TestFramework.LogInformation($"   result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/BroadcastScalarToVector256.UInt64.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/BroadcastScalarToVector256.UInt64.cs
index d39ed601a536..338358a15948 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/BroadcastScalarToVector256.UInt64.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/BroadcastScalarToVector256.UInt64.cs
@@ -312,7 +312,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -320,7 +320,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -348,9 +353,11 @@ private void ValidateResult(void* firstOp, void* result, [CallerMemberName] stri
 
         private void ValidateResult(UInt64[] firstOp, UInt64[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (firstOp[0] != result[0])
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -358,18 +365,20 @@ private void ValidateResult(UInt64[] firstOp, UInt64[] result, [CallerMemberName
                 {
                     if ((firstOp[0] != result[i]))
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Avx2)}.{nameof(Avx2.BroadcastScalarToVector256)}<UInt64>(Vector128<UInt64>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"  firstOp: ({string.Join(", ", firstOp)})");
                 TestLibrary.TestFramework.LogInformation($"   result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/CompareEqual.Byte.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/CompareEqual.Byte.cs
index 1654f17eceb2..1ffcdcf2bc19 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/CompareEqual.Byte.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/CompareEqual.Byte.cs
@@ -334,7 +334,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -342,7 +342,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -374,9 +379,11 @@ private void ValidateResult(void* left, void* right, void* result, [CallerMember
 
         private void ValidateResult(Byte[] left, Byte[] right, Byte[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (result[0] != ((left[0] == right[0]) ? unchecked((byte)(-1)) : 0))
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -384,19 +391,21 @@ private void ValidateResult(Byte[] left, Byte[] right, Byte[] result, [CallerMem
                 {
                     if (result[i] != ((left[i] == right[i]) ? unchecked((byte)(-1)) : 0))
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Avx2)}.{nameof(Avx2.CompareEqual)}<Byte>(Vector256<Byte>, Vector256<Byte>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/CompareEqual.Int16.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/CompareEqual.Int16.cs
index dc9b309a3ddb..7b6e9e1f38fc 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/CompareEqual.Int16.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/CompareEqual.Int16.cs
@@ -334,7 +334,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -342,7 +342,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -374,9 +379,11 @@ private void ValidateResult(void* left, void* right, void* result, [CallerMember
 
         private void ValidateResult(Int16[] left, Int16[] right, Int16[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (result[0] != ((left[0] == right[0]) ? unchecked((short)(-1)) : 0))
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -384,19 +391,21 @@ private void ValidateResult(Int16[] left, Int16[] right, Int16[] result, [Caller
                 {
                     if (result[i] != ((left[i] == right[i]) ? unchecked((short)(-1)) : 0))
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Avx2)}.{nameof(Avx2.CompareEqual)}<Int16>(Vector256<Int16>, Vector256<Int16>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/CompareEqual.Int32.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/CompareEqual.Int32.cs
index a980f001d3f4..de0ae8f66ccf 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/CompareEqual.Int32.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/CompareEqual.Int32.cs
@@ -334,7 +334,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -342,7 +342,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -374,9 +379,11 @@ private void ValidateResult(void* left, void* right, void* result, [CallerMember
 
         private void ValidateResult(Int32[] left, Int32[] right, Int32[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (result[0] != ((left[0] == right[0]) ? unchecked((int)(-1)) : 0))
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -384,19 +391,21 @@ private void ValidateResult(Int32[] left, Int32[] right, Int32[] result, [Caller
                 {
                     if (result[i] != ((left[i] == right[i]) ? unchecked((int)(-1)) : 0))
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Avx2)}.{nameof(Avx2.CompareEqual)}<Int32>(Vector256<Int32>, Vector256<Int32>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/CompareEqual.Int64.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/CompareEqual.Int64.cs
index 855836826f4f..61c363ed58de 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/CompareEqual.Int64.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/CompareEqual.Int64.cs
@@ -334,7 +334,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -342,7 +342,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -374,9 +379,11 @@ private void ValidateResult(void* left, void* right, void* result, [CallerMember
 
         private void ValidateResult(Int64[] left, Int64[] right, Int64[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (result[0] != ((left[0] == right[0]) ? unchecked((long)(-1)) : 0))
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -384,19 +391,21 @@ private void ValidateResult(Int64[] left, Int64[] right, Int64[] result, [Caller
                 {
                     if (result[i] != ((left[i] == right[i]) ? unchecked((long)(-1)) : 0))
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Avx2)}.{nameof(Avx2.CompareEqual)}<Int64>(Vector256<Int64>, Vector256<Int64>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/CompareEqual.SByte.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/CompareEqual.SByte.cs
index c69ab10914b5..fffb7fdccbc5 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/CompareEqual.SByte.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/CompareEqual.SByte.cs
@@ -334,7 +334,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -342,7 +342,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -374,9 +379,11 @@ private void ValidateResult(void* left, void* right, void* result, [CallerMember
 
         private void ValidateResult(SByte[] left, SByte[] right, SByte[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (result[0] != ((left[0] == right[0]) ? unchecked((sbyte)(-1)) : 0))
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -384,19 +391,21 @@ private void ValidateResult(SByte[] left, SByte[] right, SByte[] result, [Caller
                 {
                     if (result[i] != ((left[i] == right[i]) ? unchecked((sbyte)(-1)) : 0))
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Avx2)}.{nameof(Avx2.CompareEqual)}<SByte>(Vector256<SByte>, Vector256<SByte>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/CompareEqual.UInt16.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/CompareEqual.UInt16.cs
index 6e15b8076cde..0ebfa4e2964e 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/CompareEqual.UInt16.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/CompareEqual.UInt16.cs
@@ -334,7 +334,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -342,7 +342,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -374,9 +379,11 @@ private void ValidateResult(void* left, void* right, void* result, [CallerMember
 
         private void ValidateResult(UInt16[] left, UInt16[] right, UInt16[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (result[0] != ((left[0] == right[0]) ? unchecked((ushort)(-1)) : 0))
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -384,19 +391,21 @@ private void ValidateResult(UInt16[] left, UInt16[] right, UInt16[] result, [Cal
                 {
                     if (result[i] != ((left[i] == right[i]) ? unchecked((ushort)(-1)) : 0))
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Avx2)}.{nameof(Avx2.CompareEqual)}<UInt16>(Vector256<UInt16>, Vector256<UInt16>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/CompareEqual.UInt32.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/CompareEqual.UInt32.cs
index 0f188ebd1fc8..d02844877588 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/CompareEqual.UInt32.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/CompareEqual.UInt32.cs
@@ -334,7 +334,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -342,7 +342,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -374,9 +379,11 @@ private void ValidateResult(void* left, void* right, void* result, [CallerMember
 
         private void ValidateResult(UInt32[] left, UInt32[] right, UInt32[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (result[0] != ((left[0] == right[0]) ? unchecked((uint)(-1)) : 0))
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -384,19 +391,21 @@ private void ValidateResult(UInt32[] left, UInt32[] right, UInt32[] result, [Cal
                 {
                     if (result[i] != ((left[i] == right[i]) ? unchecked((uint)(-1)) : 0))
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Avx2)}.{nameof(Avx2.CompareEqual)}<UInt32>(Vector256<UInt32>, Vector256<UInt32>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/CompareEqual.UInt64.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/CompareEqual.UInt64.cs
index 23d74edc7e96..89a2494a42a7 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/CompareEqual.UInt64.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/CompareEqual.UInt64.cs
@@ -334,7 +334,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -342,7 +342,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -374,9 +379,11 @@ private void ValidateResult(void* left, void* right, void* result, [CallerMember
 
         private void ValidateResult(UInt64[] left, UInt64[] right, UInt64[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (result[0] != ((left[0] == right[0]) ? unchecked((ulong)(-1)) : 0))
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -384,19 +391,21 @@ private void ValidateResult(UInt64[] left, UInt64[] right, UInt64[] result, [Cal
                 {
                     if (result[i] != ((left[i] == right[i]) ? unchecked((ulong)(-1)) : 0))
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Avx2)}.{nameof(Avx2.CompareEqual)}<UInt64>(Vector256<UInt64>, Vector256<UInt64>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/CompareGreaterThan.Int16.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/CompareGreaterThan.Int16.cs
index f56b68069e13..991facb2d3c9 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/CompareGreaterThan.Int16.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/CompareGreaterThan.Int16.cs
@@ -334,7 +334,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -342,7 +342,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -374,9 +379,11 @@ private void ValidateResult(void* left, void* right, void* result, [CallerMember
 
         private void ValidateResult(Int16[] left, Int16[] right, Int16[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (result[0] != ((left[0] > right[0]) ? unchecked((short)(-1)) : 0))
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -384,19 +391,21 @@ private void ValidateResult(Int16[] left, Int16[] right, Int16[] result, [Caller
                 {
                     if (result[i] != ((left[i] > right[i]) ? unchecked((short)(-1)) : 0))
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Avx2)}.{nameof(Avx2.CompareGreaterThan)}<Int16>(Vector256<Int16>, Vector256<Int16>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/CompareGreaterThan.Int32.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/CompareGreaterThan.Int32.cs
index 880366975ca3..c90629c5605b 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/CompareGreaterThan.Int32.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/CompareGreaterThan.Int32.cs
@@ -334,7 +334,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -342,7 +342,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -374,9 +379,11 @@ private void ValidateResult(void* left, void* right, void* result, [CallerMember
 
         private void ValidateResult(Int32[] left, Int32[] right, Int32[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (result[0] != ((left[0] > right[0]) ? unchecked((int)(-1)) : 0))
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -384,19 +391,21 @@ private void ValidateResult(Int32[] left, Int32[] right, Int32[] result, [Caller
                 {
                     if (result[i] != ((left[i] > right[i]) ? unchecked((int)(-1)) : 0))
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Avx2)}.{nameof(Avx2.CompareGreaterThan)}<Int32>(Vector256<Int32>, Vector256<Int32>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/CompareGreaterThan.Int64.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/CompareGreaterThan.Int64.cs
index ee8cc36f67a3..fefac9fc29ae 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/CompareGreaterThan.Int64.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/CompareGreaterThan.Int64.cs
@@ -334,7 +334,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -342,7 +342,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -374,9 +379,11 @@ private void ValidateResult(void* left, void* right, void* result, [CallerMember
 
         private void ValidateResult(Int64[] left, Int64[] right, Int64[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (result[0] != ((left[0] > right[0]) ? unchecked((long)(-1)) : 0))
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -384,19 +391,21 @@ private void ValidateResult(Int64[] left, Int64[] right, Int64[] result, [Caller
                 {
                     if (result[i] != ((left[i] > right[i]) ? unchecked((long)(-1)) : 0))
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Avx2)}.{nameof(Avx2.CompareGreaterThan)}<Int64>(Vector256<Int64>, Vector256<Int64>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/CompareGreaterThan.SByte.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/CompareGreaterThan.SByte.cs
index f1e7eecfacee..44da02fe2ee1 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/CompareGreaterThan.SByte.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/CompareGreaterThan.SByte.cs
@@ -334,7 +334,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -342,7 +342,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -374,9 +379,11 @@ private void ValidateResult(void* left, void* right, void* result, [CallerMember
 
         private void ValidateResult(SByte[] left, SByte[] right, SByte[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (result[0] != ((left[0] > right[0]) ? unchecked((sbyte)(-1)) : 0))
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -384,19 +391,21 @@ private void ValidateResult(SByte[] left, SByte[] right, SByte[] result, [Caller
                 {
                     if (result[i] != ((left[i] > right[i]) ? unchecked((sbyte)(-1)) : 0))
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Avx2)}.{nameof(Avx2.CompareGreaterThan)}<SByte>(Vector256<SByte>, Vector256<SByte>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ConvertToInt32.Int32.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ConvertToInt32.Int32.cs
index 0848ed965d4e..2b5690eb081d 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ConvertToInt32.Int32.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ConvertToInt32.Int32.cs
@@ -296,7 +296,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -304,7 +304,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -324,17 +329,21 @@ private void ValidateResult(void* firstOp, Int32 result, [CallerMemberName] stri
 
         private void ValidateResult(Int32[] firstOp, Int32 result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (result != firstOp[0])
             {
-                Succeeded = false;
+                succeeded = false;
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Avx2)}.{nameof(Avx2.ConvertToInt32)}<Int32>(Vector256<Int32>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"  firstOp: ({string.Join(", ", firstOp)})");
                 TestLibrary.TestFramework.LogInformation($"   result: result");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ConvertToUInt32.UInt32.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ConvertToUInt32.UInt32.cs
index 0d12229de5d8..f7dbbb855c1b 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ConvertToUInt32.UInt32.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ConvertToUInt32.UInt32.cs
@@ -296,7 +296,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -304,7 +304,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -324,17 +329,21 @@ private void ValidateResult(void* firstOp, UInt32 result, [CallerMemberName] str
 
         private void ValidateResult(UInt32[] firstOp, UInt32 result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (result != firstOp[0])
             {
-                Succeeded = false;
+                succeeded = false;
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Avx2)}.{nameof(Avx2.ConvertToUInt32)}<UInt32>(Vector256<UInt32>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"  firstOp: ({string.Join(", ", firstOp)})");
                 TestLibrary.TestFramework.LogInformation($"   result: result");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ExtractVector128.Byte.1.Store.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ExtractVector128.Byte.1.Store.cs
index f48e72be4a57..5ee652fa13a1 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ExtractVector128.Byte.1.Store.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ExtractVector128.Byte.1.Store.cs
@@ -306,7 +306,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -314,7 +314,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -342,9 +347,11 @@ private void ValidateResult(void* firstOp, void* result, [CallerMemberName] stri
 
         private void ValidateResult(Byte[] firstOp, Byte[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (result[0] != firstOp[16])
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -352,18 +359,20 @@ private void ValidateResult(Byte[] firstOp, Byte[] result, [CallerMemberName] st
                 {
                     if ((result[i] != firstOp[i + 16]))
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Avx2)}.{nameof(Avx2.ExtractVector128)}<Byte>(Vector256<Byte><9>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"  firstOp: ({string.Join(", ", firstOp)})");
                 TestLibrary.TestFramework.LogInformation($"   result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ExtractVector128.Byte.1.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ExtractVector128.Byte.1.cs
index 3149e76475ff..ded175572502 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ExtractVector128.Byte.1.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ExtractVector128.Byte.1.cs
@@ -319,7 +319,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -327,7 +327,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -355,9 +360,11 @@ private void ValidateResult(void* firstOp, void* result, [CallerMemberName] stri
 
         private void ValidateResult(Byte[] firstOp, Byte[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (result[0] != firstOp[16])
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -365,18 +372,20 @@ private void ValidateResult(Byte[] firstOp, Byte[] result, [CallerMemberName] st
                 {
                     if ((result[i] != firstOp[i + 16]))
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Avx2)}.{nameof(Avx2.ExtractVector128)}<Byte>(Vector256<Byte><9>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"  firstOp: ({string.Join(", ", firstOp)})");
                 TestLibrary.TestFramework.LogInformation($"   result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ExtractVector128.Int16.1.Store.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ExtractVector128.Int16.1.Store.cs
index 855974f4bc87..7dfbc7450b61 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ExtractVector128.Int16.1.Store.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ExtractVector128.Int16.1.Store.cs
@@ -306,7 +306,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -314,7 +314,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -342,9 +347,11 @@ private void ValidateResult(void* firstOp, void* result, [CallerMemberName] stri
 
         private void ValidateResult(Int16[] firstOp, Int16[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (result[0] != firstOp[8])
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -352,18 +359,20 @@ private void ValidateResult(Int16[] firstOp, Int16[] result, [CallerMemberName]
                 {
                     if ((result[i] != firstOp[i + 8]))
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Avx2)}.{nameof(Avx2.ExtractVector128)}<Int16>(Vector256<Int16><9>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"  firstOp: ({string.Join(", ", firstOp)})");
                 TestLibrary.TestFramework.LogInformation($"   result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ExtractVector128.Int16.1.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ExtractVector128.Int16.1.cs
index 67e0457ba8b7..8138d7aa3caa 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ExtractVector128.Int16.1.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ExtractVector128.Int16.1.cs
@@ -319,7 +319,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -327,7 +327,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -355,9 +360,11 @@ private void ValidateResult(void* firstOp, void* result, [CallerMemberName] stri
 
         private void ValidateResult(Int16[] firstOp, Int16[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (result[0] != firstOp[8])
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -365,18 +372,20 @@ private void ValidateResult(Int16[] firstOp, Int16[] result, [CallerMemberName]
                 {
                     if ((result[i] != firstOp[i + 8]))
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Avx2)}.{nameof(Avx2.ExtractVector128)}<Int16>(Vector256<Int16><9>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"  firstOp: ({string.Join(", ", firstOp)})");
                 TestLibrary.TestFramework.LogInformation($"   result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ExtractVector128.Int32.1.Store.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ExtractVector128.Int32.1.Store.cs
index 6a58279bc078..a788e6c90f23 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ExtractVector128.Int32.1.Store.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ExtractVector128.Int32.1.Store.cs
@@ -306,7 +306,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -314,7 +314,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -342,9 +347,11 @@ private void ValidateResult(void* firstOp, void* result, [CallerMemberName] stri
 
         private void ValidateResult(Int32[] firstOp, Int32[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (result[0] != firstOp[4])
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -352,18 +359,20 @@ private void ValidateResult(Int32[] firstOp, Int32[] result, [CallerMemberName]
                 {
                     if ((result[i] != firstOp[i + 4]))
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Avx2)}.{nameof(Avx2.ExtractVector128)}<Int32>(Vector256<Int32><9>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"  firstOp: ({string.Join(", ", firstOp)})");
                 TestLibrary.TestFramework.LogInformation($"   result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ExtractVector128.Int32.1.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ExtractVector128.Int32.1.cs
index 609a149e5787..794ad807e8a5 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ExtractVector128.Int32.1.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ExtractVector128.Int32.1.cs
@@ -319,7 +319,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -327,7 +327,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -355,9 +360,11 @@ private void ValidateResult(void* firstOp, void* result, [CallerMemberName] stri
 
         private void ValidateResult(Int32[] firstOp, Int32[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (result[0] != firstOp[4])
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -365,18 +372,20 @@ private void ValidateResult(Int32[] firstOp, Int32[] result, [CallerMemberName]
                 {
                     if ((result[i] != firstOp[i + 4]))
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Avx2)}.{nameof(Avx2.ExtractVector128)}<Int32>(Vector256<Int32><9>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"  firstOp: ({string.Join(", ", firstOp)})");
                 TestLibrary.TestFramework.LogInformation($"   result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ExtractVector128.Int64.1.Store.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ExtractVector128.Int64.1.Store.cs
index 45c4dfa187de..9fa82be3834c 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ExtractVector128.Int64.1.Store.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ExtractVector128.Int64.1.Store.cs
@@ -306,7 +306,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -314,7 +314,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -342,9 +347,11 @@ private void ValidateResult(void* firstOp, void* result, [CallerMemberName] stri
 
         private void ValidateResult(Int64[] firstOp, Int64[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (result[0] != firstOp[2])
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -352,18 +359,20 @@ private void ValidateResult(Int64[] firstOp, Int64[] result, [CallerMemberName]
                 {
                     if ((result[i] != firstOp[i + 2]))
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Avx2)}.{nameof(Avx2.ExtractVector128)}<Int64>(Vector256<Int64><9>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"  firstOp: ({string.Join(", ", firstOp)})");
                 TestLibrary.TestFramework.LogInformation($"   result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ExtractVector128.Int64.1.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ExtractVector128.Int64.1.cs
index a87099428ad1..42612f8e5865 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ExtractVector128.Int64.1.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ExtractVector128.Int64.1.cs
@@ -319,7 +319,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -327,7 +327,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -355,9 +360,11 @@ private void ValidateResult(void* firstOp, void* result, [CallerMemberName] stri
 
         private void ValidateResult(Int64[] firstOp, Int64[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (result[0] != firstOp[2])
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -365,18 +372,20 @@ private void ValidateResult(Int64[] firstOp, Int64[] result, [CallerMemberName]
                 {
                     if ((result[i] != firstOp[i + 2]))
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Avx2)}.{nameof(Avx2.ExtractVector128)}<Int64>(Vector256<Int64><9>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"  firstOp: ({string.Join(", ", firstOp)})");
                 TestLibrary.TestFramework.LogInformation($"   result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ExtractVector128.SByte.1.Store.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ExtractVector128.SByte.1.Store.cs
index d2ae2487d764..9527f2aaa1f3 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ExtractVector128.SByte.1.Store.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ExtractVector128.SByte.1.Store.cs
@@ -306,7 +306,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -314,7 +314,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -342,9 +347,11 @@ private void ValidateResult(void* firstOp, void* result, [CallerMemberName] stri
 
         private void ValidateResult(SByte[] firstOp, SByte[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (result[0] != firstOp[16])
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -352,18 +359,20 @@ private void ValidateResult(SByte[] firstOp, SByte[] result, [CallerMemberName]
                 {
                     if ((result[i] != firstOp[i + 16]))
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Avx2)}.{nameof(Avx2.ExtractVector128)}<SByte>(Vector256<SByte><9>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"  firstOp: ({string.Join(", ", firstOp)})");
                 TestLibrary.TestFramework.LogInformation($"   result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ExtractVector128.SByte.1.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ExtractVector128.SByte.1.cs
index 85dc468da6b4..6685149df9cd 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ExtractVector128.SByte.1.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ExtractVector128.SByte.1.cs
@@ -319,7 +319,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -327,7 +327,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -355,9 +360,11 @@ private void ValidateResult(void* firstOp, void* result, [CallerMemberName] stri
 
         private void ValidateResult(SByte[] firstOp, SByte[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (result[0] != firstOp[16])
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -365,18 +372,20 @@ private void ValidateResult(SByte[] firstOp, SByte[] result, [CallerMemberName]
                 {
                     if ((result[i] != firstOp[i + 16]))
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Avx2)}.{nameof(Avx2.ExtractVector128)}<SByte>(Vector256<SByte><9>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"  firstOp: ({string.Join(", ", firstOp)})");
                 TestLibrary.TestFramework.LogInformation($"   result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ExtractVector128.UInt16.1.Store.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ExtractVector128.UInt16.1.Store.cs
index 3fdf5a534e7a..2cd2ba1e7996 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ExtractVector128.UInt16.1.Store.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ExtractVector128.UInt16.1.Store.cs
@@ -306,7 +306,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -314,7 +314,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -342,9 +347,11 @@ private void ValidateResult(void* firstOp, void* result, [CallerMemberName] stri
 
         private void ValidateResult(UInt16[] firstOp, UInt16[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (result[0] != firstOp[8])
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -352,18 +359,20 @@ private void ValidateResult(UInt16[] firstOp, UInt16[] result, [CallerMemberName
                 {
                     if ((result[i] != firstOp[i + 8]))
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Avx2)}.{nameof(Avx2.ExtractVector128)}<UInt16>(Vector256<UInt16><9>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"  firstOp: ({string.Join(", ", firstOp)})");
                 TestLibrary.TestFramework.LogInformation($"   result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ExtractVector128.UInt16.1.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ExtractVector128.UInt16.1.cs
index a05b91035c31..9ca7944a582c 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ExtractVector128.UInt16.1.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ExtractVector128.UInt16.1.cs
@@ -319,7 +319,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -327,7 +327,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -355,9 +360,11 @@ private void ValidateResult(void* firstOp, void* result, [CallerMemberName] stri
 
         private void ValidateResult(UInt16[] firstOp, UInt16[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (result[0] != firstOp[8])
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -365,18 +372,20 @@ private void ValidateResult(UInt16[] firstOp, UInt16[] result, [CallerMemberName
                 {
                     if ((result[i] != firstOp[i + 8]))
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Avx2)}.{nameof(Avx2.ExtractVector128)}<UInt16>(Vector256<UInt16><9>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"  firstOp: ({string.Join(", ", firstOp)})");
                 TestLibrary.TestFramework.LogInformation($"   result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ExtractVector128.UInt32.1.Store.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ExtractVector128.UInt32.1.Store.cs
index dd580b2dfd7d..0ec2752e3479 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ExtractVector128.UInt32.1.Store.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ExtractVector128.UInt32.1.Store.cs
@@ -306,7 +306,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -314,7 +314,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -342,9 +347,11 @@ private void ValidateResult(void* firstOp, void* result, [CallerMemberName] stri
 
         private void ValidateResult(UInt32[] firstOp, UInt32[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (result[0] != firstOp[4])
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -352,18 +359,20 @@ private void ValidateResult(UInt32[] firstOp, UInt32[] result, [CallerMemberName
                 {
                     if ((result[i] != firstOp[i + 4]))
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Avx2)}.{nameof(Avx2.ExtractVector128)}<UInt32>(Vector256<UInt32><9>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"  firstOp: ({string.Join(", ", firstOp)})");
                 TestLibrary.TestFramework.LogInformation($"   result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ExtractVector128.UInt32.1.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ExtractVector128.UInt32.1.cs
index 585e2a4d4520..d387188e2b2a 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ExtractVector128.UInt32.1.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ExtractVector128.UInt32.1.cs
@@ -319,7 +319,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -327,7 +327,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -355,9 +360,11 @@ private void ValidateResult(void* firstOp, void* result, [CallerMemberName] stri
 
         private void ValidateResult(UInt32[] firstOp, UInt32[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (result[0] != firstOp[4])
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -365,18 +372,20 @@ private void ValidateResult(UInt32[] firstOp, UInt32[] result, [CallerMemberName
                 {
                     if ((result[i] != firstOp[i + 4]))
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Avx2)}.{nameof(Avx2.ExtractVector128)}<UInt32>(Vector256<UInt32><9>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"  firstOp: ({string.Join(", ", firstOp)})");
                 TestLibrary.TestFramework.LogInformation($"   result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ExtractVector128.UInt64.1.Store.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ExtractVector128.UInt64.1.Store.cs
index c2c822deccb3..cbcab4296441 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ExtractVector128.UInt64.1.Store.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ExtractVector128.UInt64.1.Store.cs
@@ -306,7 +306,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -314,7 +314,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -342,9 +347,11 @@ private void ValidateResult(void* firstOp, void* result, [CallerMemberName] stri
 
         private void ValidateResult(UInt64[] firstOp, UInt64[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (result[0] != firstOp[2])
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -352,18 +359,20 @@ private void ValidateResult(UInt64[] firstOp, UInt64[] result, [CallerMemberName
                 {
                     if ((result[i] != firstOp[i + 2]))
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Avx2)}.{nameof(Avx2.ExtractVector128)}<UInt64>(Vector256<UInt64><9>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"  firstOp: ({string.Join(", ", firstOp)})");
                 TestLibrary.TestFramework.LogInformation($"   result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ExtractVector128.UInt64.1.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ExtractVector128.UInt64.1.cs
index 046abc0642cf..d77b4f22f2ed 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ExtractVector128.UInt64.1.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ExtractVector128.UInt64.1.cs
@@ -319,7 +319,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -327,7 +327,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -355,9 +360,11 @@ private void ValidateResult(void* firstOp, void* result, [CallerMemberName] stri
 
         private void ValidateResult(UInt64[] firstOp, UInt64[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (result[0] != firstOp[2])
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -365,18 +372,20 @@ private void ValidateResult(UInt64[] firstOp, UInt64[] result, [CallerMemberName
                 {
                     if ((result[i] != firstOp[i + 2]))
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Avx2)}.{nameof(Avx2.ExtractVector128)}<UInt64>(Vector256<UInt64><9>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"  firstOp: ({string.Join(", ", firstOp)})");
                 TestLibrary.TestFramework.LogInformation($"   result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/InsertVector128.Byte.1.Load.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/InsertVector128.Byte.1.Load.cs
index 4b131b222817..bbb79b603e55 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/InsertVector128.Byte.1.Load.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/InsertVector128.Byte.1.Load.cs
@@ -343,7 +343,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -351,7 +351,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -383,9 +388,11 @@ private void ValidateResult(void* left, void* right, void* result, [CallerMember
 
         private void ValidateResult(Byte[] left, Byte[] right, Byte[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (result[0] != left[0])
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -393,19 +400,21 @@ private void ValidateResult(Byte[] left, Byte[] right, Byte[] result, [CallerMem
                 {
                     if ((i > 15 ? result[i] != right[i - 16] : result[i] != left[i]))
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Avx2)}.{nameof(Avx2.InsertVector128)}<Byte>(Vector256<Byte>, Vector128<Byte>.1): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/InsertVector128.Byte.1.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/InsertVector128.Byte.1.cs
index a305f31cc52b..a68a02681dbd 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/InsertVector128.Byte.1.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/InsertVector128.Byte.1.cs
@@ -343,7 +343,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -351,7 +351,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -383,9 +388,11 @@ private void ValidateResult(void* left, void* right, void* result, [CallerMember
 
         private void ValidateResult(Byte[] left, Byte[] right, Byte[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (result[0] != left[0])
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -393,19 +400,21 @@ private void ValidateResult(Byte[] left, Byte[] right, Byte[] result, [CallerMem
                 {
                     if ((i > 15 ? result[i] != right[i - 16] : result[i] != left[i]))
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Avx2)}.{nameof(Avx2.InsertVector128)}<Byte>(Vector256<Byte>, Vector128<Byte>.1): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/InsertVector128.Int16.1.Load.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/InsertVector128.Int16.1.Load.cs
index 1d177707986d..8ef4733835e2 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/InsertVector128.Int16.1.Load.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/InsertVector128.Int16.1.Load.cs
@@ -343,7 +343,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -351,7 +351,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -383,9 +388,11 @@ private void ValidateResult(void* left, void* right, void* result, [CallerMember
 
         private void ValidateResult(Int16[] left, Int16[] right, Int16[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (result[0] != left[0])
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -393,19 +400,21 @@ private void ValidateResult(Int16[] left, Int16[] right, Int16[] result, [Caller
                 {
                     if ((i > 7 ? result[i] != right[i - 8] : result[i] != left[i]))
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Avx2)}.{nameof(Avx2.InsertVector128)}<Int16>(Vector256<Int16>, Vector128<Int16>.1): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/InsertVector128.Int16.1.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/InsertVector128.Int16.1.cs
index b9b205f85798..fd550d222b3d 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/InsertVector128.Int16.1.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/InsertVector128.Int16.1.cs
@@ -343,7 +343,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -351,7 +351,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -383,9 +388,11 @@ private void ValidateResult(void* left, void* right, void* result, [CallerMember
 
         private void ValidateResult(Int16[] left, Int16[] right, Int16[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (result[0] != left[0])
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -393,19 +400,21 @@ private void ValidateResult(Int16[] left, Int16[] right, Int16[] result, [Caller
                 {
                     if ((i > 7 ? result[i] != right[i - 8] : result[i] != left[i]))
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Avx2)}.{nameof(Avx2.InsertVector128)}<Int16>(Vector256<Int16>, Vector128<Int16>.1): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/InsertVector128.Int32.1.Load.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/InsertVector128.Int32.1.Load.cs
index 0b060c27b43d..1f9468a87aee 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/InsertVector128.Int32.1.Load.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/InsertVector128.Int32.1.Load.cs
@@ -343,7 +343,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -351,7 +351,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -383,9 +388,11 @@ private void ValidateResult(void* left, void* right, void* result, [CallerMember
 
         private void ValidateResult(Int32[] left, Int32[] right, Int32[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (result[0] != left[0])
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -393,19 +400,21 @@ private void ValidateResult(Int32[] left, Int32[] right, Int32[] result, [Caller
                 {
                     if ((i > 3 ? result[i] != right[i - 4] : result[i] != left[i]))
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Avx2)}.{nameof(Avx2.InsertVector128)}<Int32>(Vector256<Int32>, Vector128<Int32>.1): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/InsertVector128.Int32.1.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/InsertVector128.Int32.1.cs
index bc31f53ba370..4d9419e070ff 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/InsertVector128.Int32.1.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/InsertVector128.Int32.1.cs
@@ -343,7 +343,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -351,7 +351,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -383,9 +388,11 @@ private void ValidateResult(void* left, void* right, void* result, [CallerMember
 
         private void ValidateResult(Int32[] left, Int32[] right, Int32[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (result[0] != left[0])
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -393,19 +400,21 @@ private void ValidateResult(Int32[] left, Int32[] right, Int32[] result, [Caller
                 {
                     if ((i > 3 ? result[i] != right[i - 4] : result[i] != left[i]))
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Avx2)}.{nameof(Avx2.InsertVector128)}<Int32>(Vector256<Int32>, Vector128<Int32>.1): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/InsertVector128.Int64.1.Load.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/InsertVector128.Int64.1.Load.cs
index 08cd64a5c235..36e12c36d54a 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/InsertVector128.Int64.1.Load.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/InsertVector128.Int64.1.Load.cs
@@ -343,7 +343,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -351,7 +351,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -383,9 +388,11 @@ private void ValidateResult(void* left, void* right, void* result, [CallerMember
 
         private void ValidateResult(Int64[] left, Int64[] right, Int64[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (result[0] != left[0])
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -393,19 +400,21 @@ private void ValidateResult(Int64[] left, Int64[] right, Int64[] result, [Caller
                 {
                     if ((i > 1 ? result[i] != right[i - 2] : result[i] != left[i]))
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Avx2)}.{nameof(Avx2.InsertVector128)}<Int64>(Vector256<Int64>, Vector128<Int64>.1): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/InsertVector128.Int64.1.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/InsertVector128.Int64.1.cs
index 7dc2e765b7bf..3223a1bbca53 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/InsertVector128.Int64.1.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/InsertVector128.Int64.1.cs
@@ -343,7 +343,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -351,7 +351,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -383,9 +388,11 @@ private void ValidateResult(void* left, void* right, void* result, [CallerMember
 
         private void ValidateResult(Int64[] left, Int64[] right, Int64[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (result[0] != left[0])
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -393,19 +400,21 @@ private void ValidateResult(Int64[] left, Int64[] right, Int64[] result, [Caller
                 {
                     if ((i > 1 ? result[i] != right[i - 2] : result[i] != left[i]))
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Avx2)}.{nameof(Avx2.InsertVector128)}<Int64>(Vector256<Int64>, Vector128<Int64>.1): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/InsertVector128.SByte.1.Load.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/InsertVector128.SByte.1.Load.cs
index 0cd5d246e197..4c6e8e98b101 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/InsertVector128.SByte.1.Load.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/InsertVector128.SByte.1.Load.cs
@@ -343,7 +343,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -351,7 +351,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -383,9 +388,11 @@ private void ValidateResult(void* left, void* right, void* result, [CallerMember
 
         private void ValidateResult(SByte[] left, SByte[] right, SByte[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (result[0] != left[0])
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -393,19 +400,21 @@ private void ValidateResult(SByte[] left, SByte[] right, SByte[] result, [Caller
                 {
                     if ((i > 15 ? result[i] != right[i - 16] : result[i] != left[i]))
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Avx2)}.{nameof(Avx2.InsertVector128)}<SByte>(Vector256<SByte>, Vector128<SByte>.1): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/InsertVector128.SByte.1.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/InsertVector128.SByte.1.cs
index da733ac2a33d..ee1d4b1a05ab 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/InsertVector128.SByte.1.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/InsertVector128.SByte.1.cs
@@ -343,7 +343,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -351,7 +351,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -383,9 +388,11 @@ private void ValidateResult(void* left, void* right, void* result, [CallerMember
 
         private void ValidateResult(SByte[] left, SByte[] right, SByte[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (result[0] != left[0])
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -393,19 +400,21 @@ private void ValidateResult(SByte[] left, SByte[] right, SByte[] result, [Caller
                 {
                     if ((i > 15 ? result[i] != right[i - 16] : result[i] != left[i]))
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Avx2)}.{nameof(Avx2.InsertVector128)}<SByte>(Vector256<SByte>, Vector128<SByte>.1): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/InsertVector128.UInt16.1.Load.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/InsertVector128.UInt16.1.Load.cs
index 4384854243a2..bc5cacc4efd8 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/InsertVector128.UInt16.1.Load.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/InsertVector128.UInt16.1.Load.cs
@@ -343,7 +343,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -351,7 +351,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -383,9 +388,11 @@ private void ValidateResult(void* left, void* right, void* result, [CallerMember
 
         private void ValidateResult(UInt16[] left, UInt16[] right, UInt16[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (result[0] != left[0])
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -393,19 +400,21 @@ private void ValidateResult(UInt16[] left, UInt16[] right, UInt16[] result, [Cal
                 {
                     if ((i > 7 ? result[i] != right[i - 8] : result[i] != left[i]))
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Avx2)}.{nameof(Avx2.InsertVector128)}<UInt16>(Vector256<UInt16>, Vector128<UInt16>.1): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/InsertVector128.UInt16.1.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/InsertVector128.UInt16.1.cs
index 770435cee5a3..ca90995b9be4 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/InsertVector128.UInt16.1.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/InsertVector128.UInt16.1.cs
@@ -343,7 +343,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -351,7 +351,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -383,9 +388,11 @@ private void ValidateResult(void* left, void* right, void* result, [CallerMember
 
         private void ValidateResult(UInt16[] left, UInt16[] right, UInt16[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (result[0] != left[0])
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -393,19 +400,21 @@ private void ValidateResult(UInt16[] left, UInt16[] right, UInt16[] result, [Cal
                 {
                     if ((i > 7 ? result[i] != right[i - 8] : result[i] != left[i]))
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Avx2)}.{nameof(Avx2.InsertVector128)}<UInt16>(Vector256<UInt16>, Vector128<UInt16>.1): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/InsertVector128.UInt32.1.Load.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/InsertVector128.UInt32.1.Load.cs
index 46ab7a38a438..267d5e81abdf 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/InsertVector128.UInt32.1.Load.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/InsertVector128.UInt32.1.Load.cs
@@ -343,7 +343,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -351,7 +351,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -383,9 +388,11 @@ private void ValidateResult(void* left, void* right, void* result, [CallerMember
 
         private void ValidateResult(UInt32[] left, UInt32[] right, UInt32[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (result[0] != left[0])
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -393,19 +400,21 @@ private void ValidateResult(UInt32[] left, UInt32[] right, UInt32[] result, [Cal
                 {
                     if ((i > 3 ? result[i] != right[i - 4] : result[i] != left[i]))
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Avx2)}.{nameof(Avx2.InsertVector128)}<UInt32>(Vector256<UInt32>, Vector128<UInt32>.1): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/InsertVector128.UInt32.1.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/InsertVector128.UInt32.1.cs
index 2a1b551e72b1..6cb5e71b831c 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/InsertVector128.UInt32.1.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/InsertVector128.UInt32.1.cs
@@ -343,7 +343,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -351,7 +351,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -383,9 +388,11 @@ private void ValidateResult(void* left, void* right, void* result, [CallerMember
 
         private void ValidateResult(UInt32[] left, UInt32[] right, UInt32[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (result[0] != left[0])
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -393,19 +400,21 @@ private void ValidateResult(UInt32[] left, UInt32[] right, UInt32[] result, [Cal
                 {
                     if ((i > 3 ? result[i] != right[i - 4] : result[i] != left[i]))
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Avx2)}.{nameof(Avx2.InsertVector128)}<UInt32>(Vector256<UInt32>, Vector128<UInt32>.1): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/InsertVector128.UInt64.1.Load.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/InsertVector128.UInt64.1.Load.cs
index 4009cd508d24..6c3e08d1be9f 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/InsertVector128.UInt64.1.Load.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/InsertVector128.UInt64.1.Load.cs
@@ -343,7 +343,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -351,7 +351,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -383,9 +388,11 @@ private void ValidateResult(void* left, void* right, void* result, [CallerMember
 
         private void ValidateResult(UInt64[] left, UInt64[] right, UInt64[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (result[0] != left[0])
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -393,19 +400,21 @@ private void ValidateResult(UInt64[] left, UInt64[] right, UInt64[] result, [Cal
                 {
                     if ((i > 1 ? result[i] != right[i - 2] : result[i] != left[i]))
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Avx2)}.{nameof(Avx2.InsertVector128)}<UInt64>(Vector256<UInt64>, Vector128<UInt64>.1): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/InsertVector128.UInt64.1.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/InsertVector128.UInt64.1.cs
index 30fe823d3678..6e2b72d9f0d4 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/InsertVector128.UInt64.1.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/InsertVector128.UInt64.1.cs
@@ -343,7 +343,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -351,7 +351,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -383,9 +388,11 @@ private void ValidateResult(void* left, void* right, void* result, [CallerMember
 
         private void ValidateResult(UInt64[] left, UInt64[] right, UInt64[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (result[0] != left[0])
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -393,19 +400,21 @@ private void ValidateResult(UInt64[] left, UInt64[] right, UInt64[] result, [Cal
                 {
                     if ((i > 1 ? result[i] != right[i - 2] : result[i] != left[i]))
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Avx2)}.{nameof(Avx2.InsertVector128)}<UInt64>(Vector256<UInt64>, Vector128<UInt64>.1): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/MaskLoad.Int32.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/MaskLoad.Int32.cs
index 7b0c3c21c533..f282ad056ed7 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/MaskLoad.Int32.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/MaskLoad.Int32.cs
@@ -331,7 +331,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -339,7 +339,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -371,9 +376,11 @@ private void ValidateResult(void* left, void* right, void* result, [CallerMember
 
         private void ValidateResult(Int32[] left, Int32[] right, Int32[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (result[0] != ((right[0] < 0) ? left[0] : 0))
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -381,19 +388,21 @@ private void ValidateResult(Int32[] left, Int32[] right, Int32[] result, [Caller
                 {
                     if (result[i] != ((right[i] < 0) ? left[i] : 0))
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Avx2)}.{nameof(Avx2.MaskLoad)}<Int32>(Int32*, Vector256<Int32>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/MaskLoad.Int64.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/MaskLoad.Int64.cs
index 30467b24b581..1fe33160ead1 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/MaskLoad.Int64.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/MaskLoad.Int64.cs
@@ -331,7 +331,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -339,7 +339,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -371,9 +376,11 @@ private void ValidateResult(void* left, void* right, void* result, [CallerMember
 
         private void ValidateResult(Int64[] left, Int64[] right, Int64[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (result[0] != ((right[0] < 0) ? left[0] : 0))
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -381,19 +388,21 @@ private void ValidateResult(Int64[] left, Int64[] right, Int64[] result, [Caller
                 {
                     if (result[i] != ((right[i] < 0) ? left[i] : 0))
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Avx2)}.{nameof(Avx2.MaskLoad)}<Int64>(Int64*, Vector256<Int64>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/MaskLoad.UInt32.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/MaskLoad.UInt32.cs
index 8792e981972b..c23f6cc70b52 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/MaskLoad.UInt32.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/MaskLoad.UInt32.cs
@@ -331,7 +331,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -339,7 +339,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -371,9 +376,11 @@ private void ValidateResult(void* left, void* right, void* result, [CallerMember
 
         private void ValidateResult(UInt32[] left, UInt32[] right, UInt32[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (result[0] != (((right[0] & (1U << 31)) != 0) ? left[0] : 0))
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -381,19 +388,21 @@ private void ValidateResult(UInt32[] left, UInt32[] right, UInt32[] result, [Cal
                 {
                     if (result[i] != (((right[i] & (1U << 31)) != 0) ? left[i] : 0))
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Avx2)}.{nameof(Avx2.MaskLoad)}<UInt32>(UInt32*, Vector256<UInt32>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/MaskLoad.UInt64.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/MaskLoad.UInt64.cs
index b32c67bd467d..eb59b925a27a 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/MaskLoad.UInt64.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/MaskLoad.UInt64.cs
@@ -331,7 +331,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -339,7 +339,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -371,9 +376,11 @@ private void ValidateResult(void* left, void* right, void* result, [CallerMember
 
         private void ValidateResult(UInt64[] left, UInt64[] right, UInt64[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (result[0] != (((right[0] & (1UL << 63)) != 0) ? left[0] : 0))
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -381,19 +388,21 @@ private void ValidateResult(UInt64[] left, UInt64[] right, UInt64[] result, [Cal
                 {
                     if (result[i] != (((right[i] & (1UL << 63)) != 0) ? left[i] : 0))
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Avx2)}.{nameof(Avx2.MaskLoad)}<UInt64>(UInt64*, Vector256<UInt64>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/MaskStore.Int32.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/MaskStore.Int32.cs
index 4f4720b53f6d..888eed3f9704 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/MaskStore.Int32.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/MaskStore.Int32.cs
@@ -326,7 +326,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -334,7 +334,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -366,9 +371,11 @@ private void ValidateResult(void* left, void* right, void* result, [CallerMember
 
         private void ValidateResult(Int32[] left, Int32[] right, Int32[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (result[0] != ((left[0] < 0) ? right[0] : result[0]))
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -376,19 +383,21 @@ private void ValidateResult(Int32[] left, Int32[] right, Int32[] result, [Caller
                 {
                     if (result[i] != ((left[i] < 0) ? right[i] : result[i]))
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Avx2)}.{nameof(Avx2.MaskStore)}<Int32>(Vector256<Int32>, Vector256<Int32>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/MaskStore.Int64.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/MaskStore.Int64.cs
index 30f2fae6584d..d156438a382e 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/MaskStore.Int64.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/MaskStore.Int64.cs
@@ -326,7 +326,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -334,7 +334,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -366,9 +371,11 @@ private void ValidateResult(void* left, void* right, void* result, [CallerMember
 
         private void ValidateResult(Int64[] left, Int64[] right, Int64[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (result[0] != ((left[0] < 0) ? right[0] : result[0]))
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -376,19 +383,21 @@ private void ValidateResult(Int64[] left, Int64[] right, Int64[] result, [Caller
                 {
                     if (result[i] != ((left[i] < 0) ? right[i] : result[i]))
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Avx2)}.{nameof(Avx2.MaskStore)}<Int64>(Vector256<Int64>, Vector256<Int64>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/MaskStore.UInt32.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/MaskStore.UInt32.cs
index 28a548025023..b33e9d9e6204 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/MaskStore.UInt32.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/MaskStore.UInt32.cs
@@ -326,7 +326,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -334,7 +334,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -366,9 +371,11 @@ private void ValidateResult(void* left, void* right, void* result, [CallerMember
 
         private void ValidateResult(UInt32[] left, UInt32[] right, UInt32[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (result[0] != (((left[0] & (1U << 31)) != 0)  ? right[0] : result[0]))
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -376,19 +383,21 @@ private void ValidateResult(UInt32[] left, UInt32[] right, UInt32[] result, [Cal
                 {
                     if (result[i] != (((left[i] & (1U << 31)) != 0) ? right[i] : result[i]))
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Avx2)}.{nameof(Avx2.MaskStore)}<UInt32>(Vector256<UInt32>, Vector256<UInt32>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/MaskStore.UInt64.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/MaskStore.UInt64.cs
index 1beecb6ed0f0..4ffbd2f68a8a 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/MaskStore.UInt64.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/MaskStore.UInt64.cs
@@ -326,7 +326,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -334,7 +334,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -366,9 +371,11 @@ private void ValidateResult(void* left, void* right, void* result, [CallerMember
 
         private void ValidateResult(UInt64[] left, UInt64[] right, UInt64[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (result[0] != (((left[0] & (1UL << 63)) != 0)  ? right[0] : result[0]))
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -376,19 +383,21 @@ private void ValidateResult(UInt64[] left, UInt64[] right, UInt64[] result, [Cal
                 {
                     if (result[i] != (((left[i] & (1UL << 63)) != 0) ? right[i] : result[i]))
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Avx2)}.{nameof(Avx2.MaskStore)}<UInt64>(Vector256<UInt64>, Vector256<UInt64>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Max.Byte.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Max.Byte.cs
index a232b979eb93..9aaa1863d579 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Max.Byte.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Max.Byte.cs
@@ -334,7 +334,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -342,7 +342,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -374,9 +379,11 @@ private void ValidateResult(void* left, void* right, void* result, [CallerMember
 
         private void ValidateResult(Byte[] left, Byte[] right, Byte[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (result[0] != Math.Max(left[0], right[0]))
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -384,19 +391,21 @@ private void ValidateResult(Byte[] left, Byte[] right, Byte[] result, [CallerMem
                 {
                     if (result[i] != Math.Max(left[i], right[i]))
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Avx2)}.{nameof(Avx2.Max)}<Byte>(Vector256<Byte>, Vector256<Byte>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Max.Int16.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Max.Int16.cs
index 8d35d450f6c9..b4abc7b1dc29 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Max.Int16.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Max.Int16.cs
@@ -334,7 +334,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -342,7 +342,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -374,9 +379,11 @@ private void ValidateResult(void* left, void* right, void* result, [CallerMember
 
         private void ValidateResult(Int16[] left, Int16[] right, Int16[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (result[0] != Math.Max(left[0], right[0]))
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -384,19 +391,21 @@ private void ValidateResult(Int16[] left, Int16[] right, Int16[] result, [Caller
                 {
                     if (result[i] != Math.Max(left[i], right[i]))
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Avx2)}.{nameof(Avx2.Max)}<Int16>(Vector256<Int16>, Vector256<Int16>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Max.Int32.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Max.Int32.cs
index b32d0531f901..540538bd9562 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Max.Int32.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Max.Int32.cs
@@ -334,7 +334,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -342,7 +342,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -374,9 +379,11 @@ private void ValidateResult(void* left, void* right, void* result, [CallerMember
 
         private void ValidateResult(Int32[] left, Int32[] right, Int32[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (result[0] != Math.Max(left[0], right[0]))
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -384,19 +391,21 @@ private void ValidateResult(Int32[] left, Int32[] right, Int32[] result, [Caller
                 {
                     if (result[i] != Math.Max(left[i], right[i]))
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Avx2)}.{nameof(Avx2.Max)}<Int32>(Vector256<Int32>, Vector256<Int32>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Max.SByte.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Max.SByte.cs
index 517d6b9abe47..1b672c17146b 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Max.SByte.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Max.SByte.cs
@@ -334,7 +334,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -342,7 +342,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -374,9 +379,11 @@ private void ValidateResult(void* left, void* right, void* result, [CallerMember
 
         private void ValidateResult(SByte[] left, SByte[] right, SByte[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (result[0] != Math.Max(left[0], right[0]))
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -384,19 +391,21 @@ private void ValidateResult(SByte[] left, SByte[] right, SByte[] result, [Caller
                 {
                     if (result[i] != Math.Max(left[i], right[i]))
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Avx2)}.{nameof(Avx2.Max)}<SByte>(Vector256<SByte>, Vector256<SByte>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Max.UInt16.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Max.UInt16.cs
index 21016eb62e53..79c9d0500cf0 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Max.UInt16.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Max.UInt16.cs
@@ -334,7 +334,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -342,7 +342,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -374,9 +379,11 @@ private void ValidateResult(void* left, void* right, void* result, [CallerMember
 
         private void ValidateResult(UInt16[] left, UInt16[] right, UInt16[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (result[0] != Math.Max(left[0], right[0]))
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -384,19 +391,21 @@ private void ValidateResult(UInt16[] left, UInt16[] right, UInt16[] result, [Cal
                 {
                     if (result[i] != Math.Max(left[i], right[i]))
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Avx2)}.{nameof(Avx2.Max)}<UInt16>(Vector256<UInt16>, Vector256<UInt16>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Max.UInt32.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Max.UInt32.cs
index 4e572876ec2b..9027c5219cc1 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Max.UInt32.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Max.UInt32.cs
@@ -334,7 +334,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -342,7 +342,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -374,9 +379,11 @@ private void ValidateResult(void* left, void* right, void* result, [CallerMember
 
         private void ValidateResult(UInt32[] left, UInt32[] right, UInt32[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (result[0] != Math.Max(left[0], right[0]))
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -384,19 +391,21 @@ private void ValidateResult(UInt32[] left, UInt32[] right, UInt32[] result, [Cal
                 {
                     if (result[i] != Math.Max(left[i], right[i]))
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Avx2)}.{nameof(Avx2.Max)}<UInt32>(Vector256<UInt32>, Vector256<UInt32>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Min.Byte.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Min.Byte.cs
index 8725c8eb6f12..da96f474d878 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Min.Byte.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Min.Byte.cs
@@ -334,7 +334,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -342,7 +342,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -374,9 +379,11 @@ private void ValidateResult(void* left, void* right, void* result, [CallerMember
 
         private void ValidateResult(Byte[] left, Byte[] right, Byte[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (result[0] != Math.Min(left[0], right[0]))
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -384,19 +391,21 @@ private void ValidateResult(Byte[] left, Byte[] right, Byte[] result, [CallerMem
                 {
                     if (result[i] != Math.Min(left[i], right[i]))
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Avx2)}.{nameof(Avx2.Min)}<Byte>(Vector256<Byte>, Vector256<Byte>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Min.Int16.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Min.Int16.cs
index b9d65de0832e..6d73b6fabc4a 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Min.Int16.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Min.Int16.cs
@@ -334,7 +334,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -342,7 +342,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -374,9 +379,11 @@ private void ValidateResult(void* left, void* right, void* result, [CallerMember
 
         private void ValidateResult(Int16[] left, Int16[] right, Int16[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (result[0] != Math.Min(left[0], right[0]))
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -384,19 +391,21 @@ private void ValidateResult(Int16[] left, Int16[] right, Int16[] result, [Caller
                 {
                     if (result[i] != Math.Min(left[i], right[i]))
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Avx2)}.{nameof(Avx2.Min)}<Int16>(Vector256<Int16>, Vector256<Int16>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Min.Int32.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Min.Int32.cs
index 0b63051310a3..926007c8d463 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Min.Int32.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Min.Int32.cs
@@ -334,7 +334,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -342,7 +342,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -374,9 +379,11 @@ private void ValidateResult(void* left, void* right, void* result, [CallerMember
 
         private void ValidateResult(Int32[] left, Int32[] right, Int32[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (result[0] != Math.Min(left[0], right[0]))
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -384,19 +391,21 @@ private void ValidateResult(Int32[] left, Int32[] right, Int32[] result, [Caller
                 {
                     if (result[i] != Math.Min(left[i], right[i]))
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Avx2)}.{nameof(Avx2.Min)}<Int32>(Vector256<Int32>, Vector256<Int32>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Min.SByte.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Min.SByte.cs
index 16db4300ae62..c1a4bc0dfa89 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Min.SByte.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Min.SByte.cs
@@ -334,7 +334,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -342,7 +342,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -374,9 +379,11 @@ private void ValidateResult(void* left, void* right, void* result, [CallerMember
 
         private void ValidateResult(SByte[] left, SByte[] right, SByte[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (result[0] != Math.Min(left[0], right[0]))
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -384,19 +391,21 @@ private void ValidateResult(SByte[] left, SByte[] right, SByte[] result, [Caller
                 {
                     if (result[i] != Math.Min(left[i], right[i]))
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Avx2)}.{nameof(Avx2.Min)}<SByte>(Vector256<SByte>, Vector256<SByte>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Min.UInt16.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Min.UInt16.cs
index 5a61d0ec2b62..12c11661b819 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Min.UInt16.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Min.UInt16.cs
@@ -334,7 +334,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -342,7 +342,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -374,9 +379,11 @@ private void ValidateResult(void* left, void* right, void* result, [CallerMember
 
         private void ValidateResult(UInt16[] left, UInt16[] right, UInt16[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (result[0] != Math.Min(left[0], right[0]))
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -384,19 +391,21 @@ private void ValidateResult(UInt16[] left, UInt16[] right, UInt16[] result, [Cal
                 {
                     if (result[i] != Math.Min(left[i], right[i]))
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Avx2)}.{nameof(Avx2.Min)}<UInt16>(Vector256<UInt16>, Vector256<UInt16>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Min.UInt32.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Min.UInt32.cs
index bc761a1ae9e0..8cd85c53d55d 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Min.UInt32.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Min.UInt32.cs
@@ -334,7 +334,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -342,7 +342,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -374,9 +379,11 @@ private void ValidateResult(void* left, void* right, void* result, [CallerMember
 
         private void ValidateResult(UInt32[] left, UInt32[] right, UInt32[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (result[0] != Math.Min(left[0], right[0]))
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -384,19 +391,21 @@ private void ValidateResult(UInt32[] left, UInt32[] right, UInt32[] result, [Cal
                 {
                     if (result[i] != Math.Min(left[i], right[i]))
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Avx2)}.{nameof(Avx2.Min)}<UInt32>(Vector256<UInt32>, Vector256<UInt32>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/MultipleSumAbsoluteDifferences.UInt16.0.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/MultipleSumAbsoluteDifferences.UInt16.0.cs
index 84f05416abc2..a1c900146ee4 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/MultipleSumAbsoluteDifferences.UInt16.0.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/MultipleSumAbsoluteDifferences.UInt16.0.cs
@@ -341,7 +341,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -349,7 +349,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -381,9 +386,11 @@ private void ValidateResult(void* left, void* right, void* result, [CallerMember
 
         private void ValidateResult(Byte[] left, Byte[] right, UInt16[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (result[0] != (Math.Abs(left[0]-right[0])+Math.Abs(left[1]-right[1])+Math.Abs(left[2]-right[2])+Math.Abs(left[3]-right[3])))
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -391,19 +398,21 @@ private void ValidateResult(Byte[] left, Byte[] right, UInt16[] result, [CallerM
                 {
                     if (result[i] != Math.Abs(left[i%8+(i>7?16:0)]-right[0+(i>7?16:0)])+Math.Abs(left[i%8+1+(i>7?16:0)]-right[1+(i>7?16:0)])+Math.Abs(left[i%8+2+(i>7?16:0)]-right[2+(i>7?16:0)])+Math.Abs(left[i%8+3+(i>7?16:0)]-right[3+(i>7?16:0)]))
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Avx2)}.{nameof(Avx2.MultipleSumAbsoluteDifferences)}<UInt16>(Vector256<Byte>.0, Vector256<Byte>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/MultiplyAddAdjacent.Int16.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/MultiplyAddAdjacent.Int16.cs
index 74c6a728fbe2..ece325a4e4d6 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/MultiplyAddAdjacent.Int16.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/MultiplyAddAdjacent.Int16.cs
@@ -334,7 +334,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -342,7 +342,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -374,9 +379,11 @@ private void ValidateResult(void* left, void* right, void* result, [CallerMember
 
         private void ValidateResult(Byte[] left, SByte[] right, Int16[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (result[0] != Math.Clamp(((right[1] * left[1]) + (right[0] * left[0])), short.MinValue, short.MaxValue))
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -384,19 +391,21 @@ private void ValidateResult(Byte[] left, SByte[] right, Int16[] result, [CallerM
                 {
                     if (result[i] != Math.Clamp(((right[(i * 2) + 1] * left[(i * 2) + 1]) + (right[i * 2] * left[i * 2])), short.MinValue, short.MaxValue))
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Avx2)}.{nameof(Avx2.MultiplyAddAdjacent)}<Int16>(Vector256<Byte>, Vector256<SByte>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/MultiplyAddAdjacent.Int32.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/MultiplyAddAdjacent.Int32.cs
index 2908ab9fabb4..aa3d15db686e 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/MultiplyAddAdjacent.Int32.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/MultiplyAddAdjacent.Int32.cs
@@ -334,7 +334,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -342,7 +342,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -374,9 +379,11 @@ private void ValidateResult(void* left, void* right, void* result, [CallerMember
 
         private void ValidateResult(Int16[] left, Int16[] right, Int32[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (result[0] != Math.Clamp(((right[1] * left[1]) + (right[0] * left[0])), int.MinValue, int.MaxValue))
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -384,19 +391,21 @@ private void ValidateResult(Int16[] left, Int16[] right, Int32[] result, [Caller
                 {
                     if (result[i] != Math.Clamp(((right[(i * 2) + 1] * left[(i * 2) + 1]) + (right[i * 2] * left[i * 2])), int.MinValue, int.MaxValue))
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Avx2)}.{nameof(Avx2.MultiplyAddAdjacent)}<Int32>(Vector256<Int16>, Vector256<Int16>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/MultiplyHigh.Int16.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/MultiplyHigh.Int16.cs
index d437160c2da9..203cec9c6a01 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/MultiplyHigh.Int16.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/MultiplyHigh.Int16.cs
@@ -334,7 +334,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -342,7 +342,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -374,9 +379,11 @@ private void ValidateResult(void* left, void* right, void* result, [CallerMember
 
         private void ValidateResult(Int16[] left, Int16[] right, Int16[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (result[0] != BitConverter.ToInt16(BitConverter.GetBytes((((int)(left[0])) * right[0]) >> 16), 0))
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -384,19 +391,21 @@ private void ValidateResult(Int16[] left, Int16[] right, Int16[] result, [Caller
                 {
                     if (result[i] != BitConverter.ToInt16(BitConverter.GetBytes((((int)(left[i])) * right[i]) >> 16), 0))
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Avx2)}.{nameof(Avx2.MultiplyHigh)}<Int16>(Vector256<Int16>, Vector256<Int16>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/MultiplyHigh.UInt16.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/MultiplyHigh.UInt16.cs
index 5a043b23f663..5ed4dfab3e13 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/MultiplyHigh.UInt16.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/MultiplyHigh.UInt16.cs
@@ -334,7 +334,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -342,7 +342,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -374,9 +379,11 @@ private void ValidateResult(void* left, void* right, void* result, [CallerMember
 
         private void ValidateResult(UInt16[] left, UInt16[] right, UInt16[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (result[0] != BitConverter.ToUInt16(BitConverter.GetBytes((((uint)(left[0])) * right[0]) >> 16), 0))
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -384,19 +391,21 @@ private void ValidateResult(UInt16[] left, UInt16[] right, UInt16[] result, [Cal
                 {
                     if (result[i] != BitConverter.ToUInt16(BitConverter.GetBytes((((uint)(left[i])) * right[i]) >> 16), 0))
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Avx2)}.{nameof(Avx2.MultiplyHigh)}<UInt16>(Vector256<UInt16>, Vector256<UInt16>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/MultiplyHighRoundScale.Int16.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/MultiplyHighRoundScale.Int16.cs
index ab0db16cdf0f..3943f5450e53 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/MultiplyHighRoundScale.Int16.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/MultiplyHighRoundScale.Int16.cs
@@ -334,7 +334,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -342,7 +342,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -374,9 +379,11 @@ private void ValidateResult(void* left, void* right, void* result, [CallerMember
 
         private void ValidateResult(Int16[] left, Int16[] right, Int16[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (result[0] != (short)((((left[0] * right[0]) >> 14) + 1) >> 1))
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -384,19 +391,21 @@ private void ValidateResult(Int16[] left, Int16[] right, Int16[] result, [Caller
                 {
                     if (result[i] != (short)((((left[i] * right[i]) >> 14) + 1) >> 1))
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Avx2)}.{nameof(Avx2.MultiplyHighRoundScale)}<Int16>(Vector256<Int16>, Vector256<Int16>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/MultiplyLow.Int16.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/MultiplyLow.Int16.cs
index 562122f111a1..c17bdbf882a0 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/MultiplyLow.Int16.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/MultiplyLow.Int16.cs
@@ -334,7 +334,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -342,7 +342,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -374,9 +379,11 @@ private void ValidateResult(void* left, void* right, void* result, [CallerMember
 
         private void ValidateResult(Int16[] left, Int16[] right, Int16[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (result[0] != BitConverter.ToInt16(BitConverter.GetBytes(((int)(left[0])) * right[0]), 0))
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -384,19 +391,21 @@ private void ValidateResult(Int16[] left, Int16[] right, Int16[] result, [Caller
                 {
                     if (result[i] != BitConverter.ToInt16(BitConverter.GetBytes(((int)(left[i])) * right[i]), 0))
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Avx2)}.{nameof(Avx2.MultiplyLow)}<Int16>(Vector256<Int16>, Vector256<Int16>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/MultiplyLow.Int32.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/MultiplyLow.Int32.cs
index 97c30336de23..46a75f0b182d 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/MultiplyLow.Int32.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/MultiplyLow.Int32.cs
@@ -334,7 +334,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -342,7 +342,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -374,9 +379,11 @@ private void ValidateResult(void* left, void* right, void* result, [CallerMember
 
         private void ValidateResult(Int32[] left, Int32[] right, Int32[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (result[0] != BitConverter.ToInt32(BitConverter.GetBytes(((long)(left[0])) * right[0]), 0))
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -384,19 +391,21 @@ private void ValidateResult(Int32[] left, Int32[] right, Int32[] result, [Caller
                 {
                     if (result[i] != BitConverter.ToInt32(BitConverter.GetBytes(((long)(left[i])) * right[i]), 0))
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Avx2)}.{nameof(Avx2.MultiplyLow)}<Int32>(Vector256<Int32>, Vector256<Int32>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/MultiplyLow.UInt16.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/MultiplyLow.UInt16.cs
index be71fdda7c26..aed8f44e1d97 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/MultiplyLow.UInt16.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/MultiplyLow.UInt16.cs
@@ -334,7 +334,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -342,7 +342,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -374,9 +379,11 @@ private void ValidateResult(void* left, void* right, void* result, [CallerMember
 
         private void ValidateResult(UInt16[] left, UInt16[] right, UInt16[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (result[0] != BitConverter.ToUInt16(BitConverter.GetBytes(((uint)(left[0])) * right[0]), 0))
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -384,19 +391,21 @@ private void ValidateResult(UInt16[] left, UInt16[] right, UInt16[] result, [Cal
                 {
                     if (result[i] != BitConverter.ToUInt16(BitConverter.GetBytes(((uint)(left[i])) * right[i]), 0))
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Avx2)}.{nameof(Avx2.MultiplyLow)}<UInt16>(Vector256<UInt16>, Vector256<UInt16>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/MultiplyLow.UInt32.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/MultiplyLow.UInt32.cs
index 5783f840fab3..9e05ad447706 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/MultiplyLow.UInt32.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/MultiplyLow.UInt32.cs
@@ -334,7 +334,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -342,7 +342,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -374,9 +379,11 @@ private void ValidateResult(void* left, void* right, void* result, [CallerMember
 
         private void ValidateResult(UInt32[] left, UInt32[] right, UInt32[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (result[0] != BitConverter.ToUInt32(BitConverter.GetBytes(((ulong)(left[0])) * right[0]), 0))
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -384,19 +391,21 @@ private void ValidateResult(UInt32[] left, UInt32[] right, UInt32[] result, [Cal
                 {
                     if (result[i] != BitConverter.ToUInt32(BitConverter.GetBytes(((ulong)(left[i])) * right[i]), 0))
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Avx2)}.{nameof(Avx2.MultiplyLow)}<UInt32>(Vector256<UInt32>, Vector256<UInt32>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Or.Byte.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Or.Byte.cs
index 9748943f1b8c..a5760cea38e9 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Or.Byte.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Or.Byte.cs
@@ -334,7 +334,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -342,7 +342,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -374,9 +379,11 @@ private void ValidateResult(void* left, void* right, void* result, [CallerMember
 
         private void ValidateResult(Byte[] left, Byte[] right, Byte[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if ((byte)(left[0] | right[0]) != result[0])
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -384,19 +391,21 @@ private void ValidateResult(Byte[] left, Byte[] right, Byte[] result, [CallerMem
                 {
                     if ((byte)(left[i] | right[i]) != result[i])
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Avx2)}.{nameof(Avx2.Or)}<Byte>(Vector256<Byte>, Vector256<Byte>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Or.Int16.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Or.Int16.cs
index 1a2b989e2e69..61026531340a 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Or.Int16.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Or.Int16.cs
@@ -334,7 +334,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -342,7 +342,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -374,9 +379,11 @@ private void ValidateResult(void* left, void* right, void* result, [CallerMember
 
         private void ValidateResult(Int16[] left, Int16[] right, Int16[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if ((short)(left[0] | right[0]) != result[0])
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -384,19 +391,21 @@ private void ValidateResult(Int16[] left, Int16[] right, Int16[] result, [Caller
                 {
                     if ((short)(left[i] | right[i]) != result[i])
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Avx2)}.{nameof(Avx2.Or)}<Int16>(Vector256<Int16>, Vector256<Int16>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Or.Int32.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Or.Int32.cs
index 93c12908e723..219b599db6b2 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Or.Int32.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Or.Int32.cs
@@ -334,7 +334,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -342,7 +342,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -374,9 +379,11 @@ private void ValidateResult(void* left, void* right, void* result, [CallerMember
 
         private void ValidateResult(Int32[] left, Int32[] right, Int32[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if ((int)(left[0] | right[0]) != result[0])
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -384,19 +391,21 @@ private void ValidateResult(Int32[] left, Int32[] right, Int32[] result, [Caller
                 {
                     if ((int)(left[i] | right[i]) != result[i])
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Avx2)}.{nameof(Avx2.Or)}<Int32>(Vector256<Int32>, Vector256<Int32>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Or.Int64.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Or.Int64.cs
index b6e3fa813932..8a10eb4fcba5 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Or.Int64.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Or.Int64.cs
@@ -334,7 +334,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -342,7 +342,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -374,9 +379,11 @@ private void ValidateResult(void* left, void* right, void* result, [CallerMember
 
         private void ValidateResult(Int64[] left, Int64[] right, Int64[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if ((long)(left[0] | right[0]) != result[0])
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -384,19 +391,21 @@ private void ValidateResult(Int64[] left, Int64[] right, Int64[] result, [Caller
                 {
                     if ((long)(left[i] | right[i]) != result[i])
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Avx2)}.{nameof(Avx2.Or)}<Int64>(Vector256<Int64>, Vector256<Int64>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Or.SByte.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Or.SByte.cs
index 2ce37872bf77..ee271b6bff66 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Or.SByte.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Or.SByte.cs
@@ -334,7 +334,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -342,7 +342,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -374,9 +379,11 @@ private void ValidateResult(void* left, void* right, void* result, [CallerMember
 
         private void ValidateResult(SByte[] left, SByte[] right, SByte[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if ((sbyte)(left[0] | right[0]) != result[0])
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -384,19 +391,21 @@ private void ValidateResult(SByte[] left, SByte[] right, SByte[] result, [Caller
                 {
                     if ((sbyte)(left[i] | right[i]) != result[i])
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Avx2)}.{nameof(Avx2.Or)}<SByte>(Vector256<SByte>, Vector256<SByte>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Or.UInt16.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Or.UInt16.cs
index 3bcf1332255d..934b8f283765 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Or.UInt16.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Or.UInt16.cs
@@ -334,7 +334,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -342,7 +342,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -374,9 +379,11 @@ private void ValidateResult(void* left, void* right, void* result, [CallerMember
 
         private void ValidateResult(UInt16[] left, UInt16[] right, UInt16[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if ((ushort)(left[0] | right[0]) != result[0])
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -384,19 +391,21 @@ private void ValidateResult(UInt16[] left, UInt16[] right, UInt16[] result, [Cal
                 {
                     if ((ushort)(left[i] | right[i]) != result[i])
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Avx2)}.{nameof(Avx2.Or)}<UInt16>(Vector256<UInt16>, Vector256<UInt16>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Or.UInt32.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Or.UInt32.cs
index b04da6f2bd37..d6f2320698cb 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Or.UInt32.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Or.UInt32.cs
@@ -334,7 +334,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -342,7 +342,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -374,9 +379,11 @@ private void ValidateResult(void* left, void* right, void* result, [CallerMember
 
         private void ValidateResult(UInt32[] left, UInt32[] right, UInt32[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if ((uint)(left[0] | right[0]) != result[0])
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -384,19 +391,21 @@ private void ValidateResult(UInt32[] left, UInt32[] right, UInt32[] result, [Cal
                 {
                     if ((uint)(left[i] | right[i]) != result[i])
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Avx2)}.{nameof(Avx2.Or)}<UInt32>(Vector256<UInt32>, Vector256<UInt32>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Or.UInt64.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Or.UInt64.cs
index 3abe2672b180..d3a4472e34c1 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Or.UInt64.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Or.UInt64.cs
@@ -334,7 +334,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -342,7 +342,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -374,9 +379,11 @@ private void ValidateResult(void* left, void* right, void* result, [CallerMember
 
         private void ValidateResult(UInt64[] left, UInt64[] right, UInt64[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if ((ulong)(left[0] | right[0]) != result[0])
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -384,19 +391,21 @@ private void ValidateResult(UInt64[] left, UInt64[] right, UInt64[] result, [Cal
                 {
                     if ((ulong)(left[i] | right[i]) != result[i])
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Avx2)}.{nameof(Avx2.Or)}<UInt64>(Vector256<UInt64>, Vector256<UInt64>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/PackSignedSaturate.Int16.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/PackSignedSaturate.Int16.cs
index 31a8b22353b0..6b8fd8b322cd 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/PackSignedSaturate.Int16.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/PackSignedSaturate.Int16.cs
@@ -334,7 +334,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -342,7 +342,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -374,9 +379,11 @@ private void ValidateResult(void* left, void* right, void* result, [CallerMember
 
         private void ValidateResult(Int32[] left, Int32[] right, Int16[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (result[0] != (short)Math.Clamp(left[0], short.MinValue, short.MaxValue))
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -384,19 +391,21 @@ private void ValidateResult(Int32[] left, Int32[] right, Int16[] result, [Caller
                 {
                     if (result[i] != (i < 4 ? (short)Math.Clamp(left[i], short.MinValue, short.MaxValue) : (i < 8 && i > 3 ? (short)Math.Clamp(right[i%4], short.MinValue, short.MaxValue) : (i < 12 && i > 7 ? (short)Math.Clamp(left[i-4], short.MinValue, short.MaxValue) : (short)Math.Clamp(right[i-8], short.MinValue, short.MaxValue)))))
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Avx2)}.{nameof(Avx2.PackSignedSaturate)}<Int16>(Vector256<Int32>, Vector256<Int32>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/PackSignedSaturate.SByte.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/PackSignedSaturate.SByte.cs
index 7f0af06331b8..21f26ec8fdb7 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/PackSignedSaturate.SByte.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/PackSignedSaturate.SByte.cs
@@ -334,7 +334,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -342,7 +342,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -374,9 +379,11 @@ private void ValidateResult(void* left, void* right, void* result, [CallerMember
 
         private void ValidateResult(Int16[] left, Int16[] right, SByte[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (result[0] != (sbyte)Math.Clamp(left[0], sbyte.MinValue, sbyte.MaxValue))
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -384,19 +391,21 @@ private void ValidateResult(Int16[] left, Int16[] right, SByte[] result, [Caller
                 {
                     if (result[i] != (i < 8 ? (sbyte)Math.Clamp(left[i], sbyte.MinValue, sbyte.MaxValue) : (i < 16 && i > 7 ? (sbyte)Math.Clamp(right[i%8], sbyte.MinValue, sbyte.MaxValue) : (i < 24 && i > 15 ? (sbyte)Math.Clamp(left[i-8], sbyte.MinValue, sbyte.MaxValue) : (sbyte)Math.Clamp(right[i-16], sbyte.MinValue, sbyte.MaxValue)))))
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Avx2)}.{nameof(Avx2.PackSignedSaturate)}<SByte>(Vector256<Int16>, Vector256<Int16>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/PackUnsignedSaturate.Byte.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/PackUnsignedSaturate.Byte.cs
index a0aec835ff6e..939e66bacf9c 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/PackUnsignedSaturate.Byte.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/PackUnsignedSaturate.Byte.cs
@@ -334,7 +334,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -342,7 +342,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -374,9 +379,11 @@ private void ValidateResult(void* left, void* right, void* result, [CallerMember
 
         private void ValidateResult(Int16[] left, Int16[] right, Byte[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (result[0] != (byte)Math.Clamp(left[0], byte.MinValue, byte.MaxValue))
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -384,19 +391,21 @@ private void ValidateResult(Int16[] left, Int16[] right, Byte[] result, [CallerM
                 {
                     if (result[i] != (i < 8 ? (byte)Math.Clamp(left[i], byte.MinValue, byte.MaxValue) : (i < 16 && i > 7 ? (byte)Math.Clamp(right[i%8], byte.MinValue, byte.MaxValue) : (i < 24 && i > 15 ? (byte)Math.Clamp(left[i-8], byte.MinValue, byte.MaxValue) : (byte)Math.Clamp(right[i-16], byte.MinValue, byte.MaxValue)))))
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Avx2)}.{nameof(Avx2.PackUnsignedSaturate)}<Byte>(Vector256<Int16>, Vector256<Int16>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/PackUnsignedSaturate.UInt16.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/PackUnsignedSaturate.UInt16.cs
index 97dceda645ff..cae9af240ec2 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/PackUnsignedSaturate.UInt16.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/PackUnsignedSaturate.UInt16.cs
@@ -334,7 +334,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -342,7 +342,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -374,9 +379,11 @@ private void ValidateResult(void* left, void* right, void* result, [CallerMember
 
         private void ValidateResult(Int32[] left, Int32[] right, UInt16[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (result[0] != (ushort)Math.Clamp(left[0], ushort.MinValue, ushort.MaxValue))
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -384,19 +391,21 @@ private void ValidateResult(Int32[] left, Int32[] right, UInt16[] result, [Calle
                 {
                     if (result[i] != (i < 4 ? (ushort)Math.Clamp(left[i], ushort.MinValue, ushort.MaxValue) : (i < 8 && i > 3 ? (ushort)Math.Clamp(right[i%4], ushort.MinValue, ushort.MaxValue) : (i < 12 && i > 7 ? (ushort)Math.Clamp(left[i-4], ushort.MinValue, ushort.MaxValue) : (ushort)Math.Clamp(right[i-8], ushort.MinValue, ushort.MaxValue)))))
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Avx2)}.{nameof(Avx2.PackUnsignedSaturate)}<UInt16>(Vector256<Int32>, Vector256<Int32>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Permute2x128.Int32.2.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Permute2x128.Int32.2.cs
index 95bd612bd806..e71264a2d801 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Permute2x128.Int32.2.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Permute2x128.Int32.2.cs
@@ -341,7 +341,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -349,7 +349,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -381,9 +386,11 @@ private void ValidateResult(void* left, void* right, void* result, [CallerMember
 
         private void ValidateResult(Int32[] left, Int32[] right, Int32[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (result[0] != right[0])
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -391,19 +398,21 @@ private void ValidateResult(Int32[] left, Int32[] right, Int32[] result, [Caller
                 {
                     if (i > 3 ? (result[i] != left[i - 4]) : (result[i] != right[i]))
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Avx2)}.{nameof(Avx2.Permute2x128)}<Int32>(Vector256<Int32>.2, Vector256<Int32>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Permute2x128.Int64.2.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Permute2x128.Int64.2.cs
index f235f8ceefb7..2babbbdbee78 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Permute2x128.Int64.2.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Permute2x128.Int64.2.cs
@@ -341,7 +341,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -349,7 +349,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -381,9 +386,11 @@ private void ValidateResult(void* left, void* right, void* result, [CallerMember
 
         private void ValidateResult(Int64[] left, Int64[] right, Int64[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (result[0] != right[0])
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -391,19 +398,21 @@ private void ValidateResult(Int64[] left, Int64[] right, Int64[] result, [Caller
                 {
                     if (i > 1 ? (result[i] != left[i - 2]) : (result[i] != right[i]))
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Avx2)}.{nameof(Avx2.Permute2x128)}<Int64>(Vector256<Int64>.2, Vector256<Int64>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Permute2x128.UInt32.2.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Permute2x128.UInt32.2.cs
index f5c65d1337f9..841d3f891f49 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Permute2x128.UInt32.2.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Permute2x128.UInt32.2.cs
@@ -341,7 +341,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -349,7 +349,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -381,9 +386,11 @@ private void ValidateResult(void* left, void* right, void* result, [CallerMember
 
         private void ValidateResult(UInt32[] left, UInt32[] right, UInt32[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (result[0] != right[0])
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -391,19 +398,21 @@ private void ValidateResult(UInt32[] left, UInt32[] right, UInt32[] result, [Cal
                 {
                     if (i > 3 ? (result[i] != left[i - 4]) : (result[i] != right[i]))
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Avx2)}.{nameof(Avx2.Permute2x128)}<UInt32>(Vector256<UInt32>.2, Vector256<UInt32>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Permute2x128.UInt64.2.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Permute2x128.UInt64.2.cs
index 14d7bf2ad4fe..d3e836985d8d 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Permute2x128.UInt64.2.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Permute2x128.UInt64.2.cs
@@ -341,7 +341,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -349,7 +349,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -381,9 +386,11 @@ private void ValidateResult(void* left, void* right, void* result, [CallerMember
 
         private void ValidateResult(UInt64[] left, UInt64[] right, UInt64[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (result[0] != right[0])
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -391,19 +398,21 @@ private void ValidateResult(UInt64[] left, UInt64[] right, UInt64[] result, [Cal
                 {
                     if (i > 1 ? (result[i] != left[i - 2]) : (result[i] != right[i]))
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Avx2)}.{nameof(Avx2.Permute2x128)}<UInt64>(Vector256<UInt64>.2, Vector256<UInt64>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Permute4x64.Double.85.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Permute4x64.Double.85.cs
index 26b61b6b580f..e47a3acecccb 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Permute4x64.Double.85.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Permute4x64.Double.85.cs
@@ -319,7 +319,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -327,7 +327,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -355,9 +360,11 @@ private void ValidateResult(void* firstOp, void* result, [CallerMemberName] stri
 
         private void ValidateResult(Double[] firstOp, Double[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (BitConverter.DoubleToInt64Bits(firstOp[1]) != BitConverter.DoubleToInt64Bits(result[0]))
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -365,18 +372,20 @@ private void ValidateResult(Double[] firstOp, Double[] result, [CallerMemberName
                 {
                     if (BitConverter.DoubleToInt64Bits(firstOp[1])  != BitConverter.DoubleToInt64Bits(result[i]))
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Avx2)}.{nameof(Avx2.Permute4x64)}<Double>(Vector256<Double><9>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"  firstOp: ({string.Join(", ", firstOp)})");
                 TestLibrary.TestFramework.LogInformation($"   result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Permute4x64.Int64.85.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Permute4x64.Int64.85.cs
index 89ccea0bac3d..917f18c73634 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Permute4x64.Int64.85.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Permute4x64.Int64.85.cs
@@ -319,7 +319,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -327,7 +327,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -355,9 +360,11 @@ private void ValidateResult(void* firstOp, void* result, [CallerMemberName] stri
 
         private void ValidateResult(Int64[] firstOp, Int64[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (firstOp[1] != result[0])
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -365,18 +372,20 @@ private void ValidateResult(Int64[] firstOp, Int64[] result, [CallerMemberName]
                 {
                     if (firstOp[1] != result[i])
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Avx2)}.{nameof(Avx2.Permute4x64)}<Int64>(Vector256<Int64><9>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"  firstOp: ({string.Join(", ", firstOp)})");
                 TestLibrary.TestFramework.LogInformation($"   result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Permute4x64.UInt64.85.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Permute4x64.UInt64.85.cs
index 7f93b9b31c55..16cf1ca266cd 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Permute4x64.UInt64.85.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Permute4x64.UInt64.85.cs
@@ -319,7 +319,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -327,7 +327,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -355,9 +360,11 @@ private void ValidateResult(void* firstOp, void* result, [CallerMemberName] stri
 
         private void ValidateResult(UInt64[] firstOp, UInt64[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (firstOp[1] != result[0])
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -365,18 +372,20 @@ private void ValidateResult(UInt64[] firstOp, UInt64[] result, [CallerMemberName
                 {
                     if (firstOp[1] != result[i])
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Avx2)}.{nameof(Avx2.Permute4x64)}<UInt64>(Vector256<UInt64><9>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"  firstOp: ({string.Join(", ", firstOp)})");
                 TestLibrary.TestFramework.LogInformation($"   result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/PermuteVar8x32.Int32.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/PermuteVar8x32.Int32.cs
index d0a7d5f7bcc6..26b41939ff05 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/PermuteVar8x32.Int32.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/PermuteVar8x32.Int32.cs
@@ -334,7 +334,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -342,7 +342,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -374,9 +379,11 @@ private void ValidateResult(void* left, void* right, void* result, [CallerMember
 
         private void ValidateResult(Int32[] left, Int32[] right, Int32[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (left[(right[0] & 7)] != result[0])
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -384,19 +391,21 @@ private void ValidateResult(Int32[] left, Int32[] right, Int32[] result, [Caller
                 {
                     if (left[(right[i] & 7)] != result[i])
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Avx2)}.{nameof(Avx2.PermuteVar8x32)}<Int32>(Vector256<Int32>, Vector256<Int32>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/PermuteVar8x32.Single.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/PermuteVar8x32.Single.cs
index c72c691fafa4..cacf5ef06d7f 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/PermuteVar8x32.Single.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/PermuteVar8x32.Single.cs
@@ -334,7 +334,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -342,7 +342,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -374,9 +379,11 @@ private void ValidateResult(void* left, void* right, void* result, [CallerMember
 
         private void ValidateResult(Single[] left, Int32[] right, Single[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (BitConverter.SingleToInt32Bits(left[(right[0] & 7)]) != BitConverter.SingleToInt32Bits(result[0]))
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -384,19 +391,21 @@ private void ValidateResult(Single[] left, Int32[] right, Single[] result, [Call
                 {
                     if (BitConverter.SingleToInt32Bits(left[(right[i] & 7)]) != BitConverter.SingleToInt32Bits(result[i]))
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Avx2)}.{nameof(Avx2.PermuteVar8x32)}<Single>(Vector256<Single>, Vector256<Int32>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/PermuteVar8x32.UInt32.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/PermuteVar8x32.UInt32.cs
index 54512c4ae6a4..998e9af6a740 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/PermuteVar8x32.UInt32.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/PermuteVar8x32.UInt32.cs
@@ -334,7 +334,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -342,7 +342,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -374,9 +379,11 @@ private void ValidateResult(void* left, void* right, void* result, [CallerMember
 
         private void ValidateResult(UInt32[] left, UInt32[] right, UInt32[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (left[(right[0] & (uint)7)] != result[0])
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -384,19 +391,21 @@ private void ValidateResult(UInt32[] left, UInt32[] right, UInt32[] result, [Cal
                 {
                     if (left[(right[i] & (uint)7)] != result[i])
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Avx2)}.{nameof(Avx2.PermuteVar8x32)}<UInt32>(Vector256<UInt32>, Vector256<UInt32>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ShiftLeftLogical.Int16.1.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ShiftLeftLogical.Int16.1.cs
index 61cc47eb5103..8445b8a66c55 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ShiftLeftLogical.Int16.1.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ShiftLeftLogical.Int16.1.cs
@@ -319,7 +319,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -327,7 +327,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -355,9 +360,11 @@ private void ValidateResult(void* firstOp, void* result, [CallerMemberName] stri
 
         private void ValidateResult(Int16[] firstOp, Int16[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if ((short)(firstOp[0] << 1) != result[0])
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -365,18 +372,20 @@ private void ValidateResult(Int16[] firstOp, Int16[] result, [CallerMemberName]
                 {
                     if ((short)(firstOp[i] << 1) != result[i])
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Avx2)}.{nameof(Avx2.ShiftLeftLogical)}<Int16>(Vector256<Int16><9>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"  firstOp: ({string.Join(", ", firstOp)})");
                 TestLibrary.TestFramework.LogInformation($"   result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ShiftLeftLogical.Int16.16.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ShiftLeftLogical.Int16.16.cs
index f2b7c6e6bbb6..c3faa44f6445 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ShiftLeftLogical.Int16.16.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ShiftLeftLogical.Int16.16.cs
@@ -319,7 +319,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -327,7 +327,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -355,9 +360,11 @@ private void ValidateResult(void* firstOp, void* result, [CallerMemberName] stri
 
         private void ValidateResult(Int16[] firstOp, Int16[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (0 != result[0])
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -365,18 +372,20 @@ private void ValidateResult(Int16[] firstOp, Int16[] result, [CallerMemberName]
                 {
                     if (0 != result[i])
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Avx2)}.{nameof(Avx2.ShiftLeftLogical)}<Int16>(Vector256<Int16><9>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"  firstOp: ({string.Join(", ", firstOp)})");
                 TestLibrary.TestFramework.LogInformation($"   result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ShiftLeftLogical.Int32.1.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ShiftLeftLogical.Int32.1.cs
index 20f0ae8e9f46..571aeaec54a8 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ShiftLeftLogical.Int32.1.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ShiftLeftLogical.Int32.1.cs
@@ -319,7 +319,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -327,7 +327,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -355,9 +360,11 @@ private void ValidateResult(void* firstOp, void* result, [CallerMemberName] stri
 
         private void ValidateResult(Int32[] firstOp, Int32[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if ((int)(firstOp[0] << 1) != result[0])
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -365,18 +372,20 @@ private void ValidateResult(Int32[] firstOp, Int32[] result, [CallerMemberName]
                 {
                     if ((int)(firstOp[i] << 1) != result[i])
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Avx2)}.{nameof(Avx2.ShiftLeftLogical)}<Int32>(Vector256<Int32><9>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"  firstOp: ({string.Join(", ", firstOp)})");
                 TestLibrary.TestFramework.LogInformation($"   result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ShiftLeftLogical.Int32.32.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ShiftLeftLogical.Int32.32.cs
index 99759779ade1..c7c6b5a02b0f 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ShiftLeftLogical.Int32.32.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ShiftLeftLogical.Int32.32.cs
@@ -319,7 +319,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -327,7 +327,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -355,9 +360,11 @@ private void ValidateResult(void* firstOp, void* result, [CallerMemberName] stri
 
         private void ValidateResult(Int32[] firstOp, Int32[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (0 != result[0])
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -365,18 +372,20 @@ private void ValidateResult(Int32[] firstOp, Int32[] result, [CallerMemberName]
                 {
                     if (0 != result[i])
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Avx2)}.{nameof(Avx2.ShiftLeftLogical)}<Int32>(Vector256<Int32><9>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"  firstOp: ({string.Join(", ", firstOp)})");
                 TestLibrary.TestFramework.LogInformation($"   result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ShiftLeftLogical.Int64.1.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ShiftLeftLogical.Int64.1.cs
index c7409a01a50a..c897a2a62196 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ShiftLeftLogical.Int64.1.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ShiftLeftLogical.Int64.1.cs
@@ -319,7 +319,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -327,7 +327,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -355,9 +360,11 @@ private void ValidateResult(void* firstOp, void* result, [CallerMemberName] stri
 
         private void ValidateResult(Int64[] firstOp, Int64[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if ((long)(firstOp[0] << 1) != result[0])
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -365,18 +372,20 @@ private void ValidateResult(Int64[] firstOp, Int64[] result, [CallerMemberName]
                 {
                     if ((long)(firstOp[i] << 1) != result[i])
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Avx2)}.{nameof(Avx2.ShiftLeftLogical)}<Int64>(Vector256<Int64><9>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"  firstOp: ({string.Join(", ", firstOp)})");
                 TestLibrary.TestFramework.LogInformation($"   result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ShiftLeftLogical.Int64.64.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ShiftLeftLogical.Int64.64.cs
index 8f628f91c8bb..a6c057c20035 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ShiftLeftLogical.Int64.64.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ShiftLeftLogical.Int64.64.cs
@@ -319,7 +319,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -327,7 +327,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -355,9 +360,11 @@ private void ValidateResult(void* firstOp, void* result, [CallerMemberName] stri
 
         private void ValidateResult(Int64[] firstOp, Int64[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (0 != result[0])
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -365,18 +372,20 @@ private void ValidateResult(Int64[] firstOp, Int64[] result, [CallerMemberName]
                 {
                     if (0 != result[i])
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Avx2)}.{nameof(Avx2.ShiftLeftLogical)}<Int64>(Vector256<Int64><9>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"  firstOp: ({string.Join(", ", firstOp)})");
                 TestLibrary.TestFramework.LogInformation($"   result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ShiftLeftLogical.UInt16.1.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ShiftLeftLogical.UInt16.1.cs
index d84b46e33fea..fbec55862bb0 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ShiftLeftLogical.UInt16.1.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ShiftLeftLogical.UInt16.1.cs
@@ -319,7 +319,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -327,7 +327,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -355,9 +360,11 @@ private void ValidateResult(void* firstOp, void* result, [CallerMemberName] stri
 
         private void ValidateResult(UInt16[] firstOp, UInt16[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if ((ushort)(firstOp[0] << 1) != result[0])
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -365,18 +372,20 @@ private void ValidateResult(UInt16[] firstOp, UInt16[] result, [CallerMemberName
                 {
                     if ((ushort)(firstOp[i] << 1) != result[i])
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Avx2)}.{nameof(Avx2.ShiftLeftLogical)}<UInt16>(Vector256<UInt16><9>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"  firstOp: ({string.Join(", ", firstOp)})");
                 TestLibrary.TestFramework.LogInformation($"   result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ShiftLeftLogical.UInt16.16.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ShiftLeftLogical.UInt16.16.cs
index 0c4dbcd1d70c..8afb117dad3a 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ShiftLeftLogical.UInt16.16.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ShiftLeftLogical.UInt16.16.cs
@@ -319,7 +319,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -327,7 +327,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -355,9 +360,11 @@ private void ValidateResult(void* firstOp, void* result, [CallerMemberName] stri
 
         private void ValidateResult(UInt16[] firstOp, UInt16[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (0 != result[0])
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -365,18 +372,20 @@ private void ValidateResult(UInt16[] firstOp, UInt16[] result, [CallerMemberName
                 {
                     if (0 != result[i])
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Avx2)}.{nameof(Avx2.ShiftLeftLogical)}<UInt16>(Vector256<UInt16><9>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"  firstOp: ({string.Join(", ", firstOp)})");
                 TestLibrary.TestFramework.LogInformation($"   result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ShiftLeftLogical.UInt32.1.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ShiftLeftLogical.UInt32.1.cs
index ac8519e75377..8f4515884f08 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ShiftLeftLogical.UInt32.1.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ShiftLeftLogical.UInt32.1.cs
@@ -319,7 +319,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -327,7 +327,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -355,9 +360,11 @@ private void ValidateResult(void* firstOp, void* result, [CallerMemberName] stri
 
         private void ValidateResult(UInt32[] firstOp, UInt32[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if ((uint)(firstOp[0] << 1) != result[0])
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -365,18 +372,20 @@ private void ValidateResult(UInt32[] firstOp, UInt32[] result, [CallerMemberName
                 {
                     if ((uint)(firstOp[i] << 1) != result[i])
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Avx2)}.{nameof(Avx2.ShiftLeftLogical)}<UInt32>(Vector256<UInt32><9>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"  firstOp: ({string.Join(", ", firstOp)})");
                 TestLibrary.TestFramework.LogInformation($"   result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ShiftLeftLogical.UInt32.32.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ShiftLeftLogical.UInt32.32.cs
index bdc58b541dba..c84d457ff8f5 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ShiftLeftLogical.UInt32.32.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ShiftLeftLogical.UInt32.32.cs
@@ -319,7 +319,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -327,7 +327,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -355,9 +360,11 @@ private void ValidateResult(void* firstOp, void* result, [CallerMemberName] stri
 
         private void ValidateResult(UInt32[] firstOp, UInt32[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (0 != result[0])
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -365,18 +372,20 @@ private void ValidateResult(UInt32[] firstOp, UInt32[] result, [CallerMemberName
                 {
                     if (0!= result[i])
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Avx2)}.{nameof(Avx2.ShiftLeftLogical)}<UInt32>(Vector256<UInt32><9>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"  firstOp: ({string.Join(", ", firstOp)})");
                 TestLibrary.TestFramework.LogInformation($"   result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ShiftLeftLogical.UInt64.1.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ShiftLeftLogical.UInt64.1.cs
index 9590c3edb19d..316d7e2f7b2f 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ShiftLeftLogical.UInt64.1.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ShiftLeftLogical.UInt64.1.cs
@@ -319,7 +319,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -327,7 +327,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -355,9 +360,11 @@ private void ValidateResult(void* firstOp, void* result, [CallerMemberName] stri
 
         private void ValidateResult(UInt64[] firstOp, UInt64[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if ((ulong)(firstOp[0] << 1) != result[0])
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -365,18 +372,20 @@ private void ValidateResult(UInt64[] firstOp, UInt64[] result, [CallerMemberName
                 {
                     if ((ulong)(firstOp[i] << 1) != result[i])
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Avx2)}.{nameof(Avx2.ShiftLeftLogical)}<UInt64>(Vector256<UInt64><9>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"  firstOp: ({string.Join(", ", firstOp)})");
                 TestLibrary.TestFramework.LogInformation($"   result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ShiftLeftLogical.UInt64.64.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ShiftLeftLogical.UInt64.64.cs
index 3ee6cb9ee6c3..f97b3cb15726 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ShiftLeftLogical.UInt64.64.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ShiftLeftLogical.UInt64.64.cs
@@ -319,7 +319,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -327,7 +327,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -355,9 +360,11 @@ private void ValidateResult(void* firstOp, void* result, [CallerMemberName] stri
 
         private void ValidateResult(UInt64[] firstOp, UInt64[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (0 != result[0])
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -365,18 +372,20 @@ private void ValidateResult(UInt64[] firstOp, UInt64[] result, [CallerMemberName
                 {
                     if (0 != result[i])
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Avx2)}.{nameof(Avx2.ShiftLeftLogical)}<UInt64>(Vector256<UInt64><9>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"  firstOp: ({string.Join(", ", firstOp)})");
                 TestLibrary.TestFramework.LogInformation($"   result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ShiftLeftLogical128BitLane.Byte.1.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ShiftLeftLogical128BitLane.Byte.1.cs
index c4802f32cbb8..ee3edeb2650d 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ShiftLeftLogical128BitLane.Byte.1.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ShiftLeftLogical128BitLane.Byte.1.cs
@@ -319,7 +319,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -327,7 +327,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -355,9 +360,11 @@ private void ValidateResult(void* firstOp, void* result, [CallerMemberName] stri
 
         private void ValidateResult(Byte[] firstOp, Byte[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (result[0] != 0)
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -365,18 +372,20 @@ private void ValidateResult(Byte[] firstOp, Byte[] result, [CallerMemberName] st
                 {
                     if ((i == 16 ? result[i] != 0 : result[i] != 8))
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Avx2)}.{nameof(Avx2.ShiftLeftLogical128BitLane)}<Byte>(Vector256<Byte><9>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"  firstOp: ({string.Join(", ", firstOp)})");
                 TestLibrary.TestFramework.LogInformation($"   result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ShiftLeftLogical128BitLane.Int16.1.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ShiftLeftLogical128BitLane.Int16.1.cs
index 903b2a319941..35cdb4a8e5a8 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ShiftLeftLogical128BitLane.Int16.1.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ShiftLeftLogical128BitLane.Int16.1.cs
@@ -319,7 +319,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -327,7 +327,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -355,9 +360,11 @@ private void ValidateResult(void* firstOp, void* result, [CallerMemberName] stri
 
         private void ValidateResult(Int16[] firstOp, Int16[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (result[0] != 2048)
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -365,18 +372,20 @@ private void ValidateResult(Int16[] firstOp, Int16[] result, [CallerMemberName]
                 {
                     if (result[i] != 2048)
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Avx2)}.{nameof(Avx2.ShiftLeftLogical128BitLane)}<Int16>(Vector256<Int16><9>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"  firstOp: ({string.Join(", ", firstOp)})");
                 TestLibrary.TestFramework.LogInformation($"   result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ShiftLeftLogical128BitLane.Int32.1.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ShiftLeftLogical128BitLane.Int32.1.cs
index e92560ff6c87..574e71616825 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ShiftLeftLogical128BitLane.Int32.1.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ShiftLeftLogical128BitLane.Int32.1.cs
@@ -319,7 +319,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -327,7 +327,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -355,9 +360,11 @@ private void ValidateResult(void* firstOp, void* result, [CallerMemberName] stri
 
         private void ValidateResult(Int32[] firstOp, Int32[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (result[0] != 2048)
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -365,18 +372,20 @@ private void ValidateResult(Int32[] firstOp, Int32[] result, [CallerMemberName]
                 {
                     if (result[i] != 2048)
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Avx2)}.{nameof(Avx2.ShiftLeftLogical128BitLane)}<Int32>(Vector256<Int32><9>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"  firstOp: ({string.Join(", ", firstOp)})");
                 TestLibrary.TestFramework.LogInformation($"   result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ShiftLeftLogical128BitLane.Int64.1.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ShiftLeftLogical128BitLane.Int64.1.cs
index 231406454de8..524012ec7e3c 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ShiftLeftLogical128BitLane.Int64.1.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ShiftLeftLogical128BitLane.Int64.1.cs
@@ -319,7 +319,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -327,7 +327,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -355,9 +360,11 @@ private void ValidateResult(void* firstOp, void* result, [CallerMemberName] stri
 
         private void ValidateResult(Int64[] firstOp, Int64[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (result[0] != 2048)
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -365,18 +372,20 @@ private void ValidateResult(Int64[] firstOp, Int64[] result, [CallerMemberName]
                 {
                     if (result[i] != 2048)
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Avx2)}.{nameof(Avx2.ShiftLeftLogical128BitLane)}<Int64>(Vector256<Int64><9>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"  firstOp: ({string.Join(", ", firstOp)})");
                 TestLibrary.TestFramework.LogInformation($"   result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ShiftLeftLogical128BitLane.SByte.1.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ShiftLeftLogical128BitLane.SByte.1.cs
index 4dc13fca685c..112845ee1570 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ShiftLeftLogical128BitLane.SByte.1.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ShiftLeftLogical128BitLane.SByte.1.cs
@@ -319,7 +319,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -327,7 +327,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -355,9 +360,11 @@ private void ValidateResult(void* firstOp, void* result, [CallerMemberName] stri
 
         private void ValidateResult(SByte[] firstOp, SByte[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (result[0] != 0)
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -365,18 +372,20 @@ private void ValidateResult(SByte[] firstOp, SByte[] result, [CallerMemberName]
                 {
                     if ((i == 16 ? result[i] != 0 : result[i] != 8))
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Avx2)}.{nameof(Avx2.ShiftLeftLogical128BitLane)}<SByte>(Vector256<SByte><9>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"  firstOp: ({string.Join(", ", firstOp)})");
                 TestLibrary.TestFramework.LogInformation($"   result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ShiftLeftLogical128BitLane.UInt16.1.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ShiftLeftLogical128BitLane.UInt16.1.cs
index 864a3a27485d..31b9d615991a 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ShiftLeftLogical128BitLane.UInt16.1.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ShiftLeftLogical128BitLane.UInt16.1.cs
@@ -319,7 +319,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -327,7 +327,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -355,9 +360,11 @@ private void ValidateResult(void* firstOp, void* result, [CallerMemberName] stri
 
         private void ValidateResult(UInt16[] firstOp, UInt16[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (result[0] != 2048)
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -365,18 +372,20 @@ private void ValidateResult(UInt16[] firstOp, UInt16[] result, [CallerMemberName
                 {
                     if (result[i] != 2048)
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Avx2)}.{nameof(Avx2.ShiftLeftLogical128BitLane)}<UInt16>(Vector256<UInt16><9>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"  firstOp: ({string.Join(", ", firstOp)})");
                 TestLibrary.TestFramework.LogInformation($"   result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ShiftLeftLogical128BitLane.UInt32.1.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ShiftLeftLogical128BitLane.UInt32.1.cs
index becf8bc2841f..6b1f0eb85f6f 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ShiftLeftLogical128BitLane.UInt32.1.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ShiftLeftLogical128BitLane.UInt32.1.cs
@@ -319,7 +319,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -327,7 +327,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -355,9 +360,11 @@ private void ValidateResult(void* firstOp, void* result, [CallerMemberName] stri
 
         private void ValidateResult(UInt32[] firstOp, UInt32[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (result[0] != 2048)
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -365,18 +372,20 @@ private void ValidateResult(UInt32[] firstOp, UInt32[] result, [CallerMemberName
                 {
                     if (result[i] != 2048)
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Avx2)}.{nameof(Avx2.ShiftLeftLogical128BitLane)}<UInt32>(Vector256<UInt32><9>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"  firstOp: ({string.Join(", ", firstOp)})");
                 TestLibrary.TestFramework.LogInformation($"   result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ShiftLeftLogical128BitLane.UInt64.1.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ShiftLeftLogical128BitLane.UInt64.1.cs
index 72a57bbaec56..a51333e8ed2c 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ShiftLeftLogical128BitLane.UInt64.1.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ShiftLeftLogical128BitLane.UInt64.1.cs
@@ -319,7 +319,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -327,7 +327,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -355,9 +360,11 @@ private void ValidateResult(void* firstOp, void* result, [CallerMemberName] stri
 
         private void ValidateResult(UInt64[] firstOp, UInt64[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (result[0] != 2048)
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -365,18 +372,20 @@ private void ValidateResult(UInt64[] firstOp, UInt64[] result, [CallerMemberName
                 {
                     if (result[i] != 2048)
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Avx2)}.{nameof(Avx2.ShiftLeftLogical128BitLane)}<UInt64>(Vector256<UInt64><9>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"  firstOp: ({string.Join(", ", firstOp)})");
                 TestLibrary.TestFramework.LogInformation($"   result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ShiftRightArithmetic.Int16.1.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ShiftRightArithmetic.Int16.1.cs
index 206a6326be74..1f2181bcfff2 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ShiftRightArithmetic.Int16.1.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ShiftRightArithmetic.Int16.1.cs
@@ -319,7 +319,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -327,7 +327,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -355,9 +360,11 @@ private void ValidateResult(void* firstOp, void* result, [CallerMemberName] stri
 
         private void ValidateResult(Int16[] firstOp, Int16[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if ((short)(firstOp[0] >> 1) != result[0])
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -365,18 +372,20 @@ private void ValidateResult(Int16[] firstOp, Int16[] result, [CallerMemberName]
                 {
                     if ((short)(firstOp[i] >> 1) != result[i])
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Avx2)}.{nameof(Avx2.ShiftRightArithmetic)}<Int16>(Vector256<Int16><9>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"  firstOp: ({string.Join(", ", firstOp)})");
                 TestLibrary.TestFramework.LogInformation($"   result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ShiftRightArithmetic.Int16.16.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ShiftRightArithmetic.Int16.16.cs
index ece284e0e744..305a96937554 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ShiftRightArithmetic.Int16.16.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ShiftRightArithmetic.Int16.16.cs
@@ -319,7 +319,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -327,7 +327,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -355,9 +360,11 @@ private void ValidateResult(void* firstOp, void* result, [CallerMemberName] stri
 
         private void ValidateResult(Int16[] firstOp, Int16[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if ((short)(firstOp[0] >> 15) != result[0])
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -365,18 +372,20 @@ private void ValidateResult(Int16[] firstOp, Int16[] result, [CallerMemberName]
                 {
                     if ((short)(firstOp[i] >> 15) != result[i])
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Avx2)}.{nameof(Avx2.ShiftRightArithmetic)}<Int16>(Vector256<Int16><9>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"  firstOp: ({string.Join(", ", firstOp)})");
                 TestLibrary.TestFramework.LogInformation($"   result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ShiftRightArithmetic.Int32.1.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ShiftRightArithmetic.Int32.1.cs
index e5abdf447995..2a95b3e02037 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ShiftRightArithmetic.Int32.1.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ShiftRightArithmetic.Int32.1.cs
@@ -319,7 +319,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -327,7 +327,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -355,9 +360,11 @@ private void ValidateResult(void* firstOp, void* result, [CallerMemberName] stri
 
         private void ValidateResult(Int32[] firstOp, Int32[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if ((int)(firstOp[0] >> 1) != result[0])
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -365,18 +372,20 @@ private void ValidateResult(Int32[] firstOp, Int32[] result, [CallerMemberName]
                 {
                     if ((int)(firstOp[i] >> 1) != result[i])
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Avx2)}.{nameof(Avx2.ShiftRightArithmetic)}<Int32>(Vector256<Int32><9>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"  firstOp: ({string.Join(", ", firstOp)})");
                 TestLibrary.TestFramework.LogInformation($"   result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ShiftRightArithmetic.Int32.32.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ShiftRightArithmetic.Int32.32.cs
index 9907120245fe..a96bc4c09bce 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ShiftRightArithmetic.Int32.32.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ShiftRightArithmetic.Int32.32.cs
@@ -319,7 +319,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -327,7 +327,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -355,9 +360,11 @@ private void ValidateResult(void* firstOp, void* result, [CallerMemberName] stri
 
         private void ValidateResult(Int32[] firstOp, Int32[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if ((int)(firstOp[0] >> 31) != result[0])
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -365,18 +372,20 @@ private void ValidateResult(Int32[] firstOp, Int32[] result, [CallerMemberName]
                 {
                     if ((int)(firstOp[i] >> 31) != result[i])
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Avx2)}.{nameof(Avx2.ShiftRightArithmetic)}<Int32>(Vector256<Int32><9>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"  firstOp: ({string.Join(", ", firstOp)})");
                 TestLibrary.TestFramework.LogInformation($"   result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ShiftRightArithmeticVariable.Int32.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ShiftRightArithmeticVariable.Int32.cs
index a8c156cd3530..d814cdca35f0 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ShiftRightArithmeticVariable.Int32.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ShiftRightArithmeticVariable.Int32.cs
@@ -334,7 +334,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -342,7 +342,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -374,9 +379,11 @@ private void ValidateResult(void* left, void* right, void* result, [CallerMember
 
         private void ValidateResult(Int32[] left, UInt32[] right, Int32[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if ((int)(left[0] >> (int)right[0]) != result[0])
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -384,19 +391,21 @@ private void ValidateResult(Int32[] left, UInt32[] right, Int32[] result, [Calle
                 {
                     if ((int)(left[i] >> (int)right[i]) != result[i])
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Avx2)}.{nameof(Avx2.ShiftRightArithmeticVariable)}<Int32>(Vector256<Int32>, Vector256<UInt32>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ShiftRightLogical.Int16.1.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ShiftRightLogical.Int16.1.cs
index 6c28a9e38a8c..a0d7c79bdaa2 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ShiftRightLogical.Int16.1.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ShiftRightLogical.Int16.1.cs
@@ -319,7 +319,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -327,7 +327,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -355,9 +360,11 @@ private void ValidateResult(void* firstOp, void* result, [CallerMemberName] stri
 
         private void ValidateResult(Int16[] firstOp, Int16[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if ((short)(firstOp[0] >> 1) != result[0])
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -365,18 +372,20 @@ private void ValidateResult(Int16[] firstOp, Int16[] result, [CallerMemberName]
                 {
                     if ((short)(firstOp[i] >> 1) != result[i])
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Avx2)}.{nameof(Avx2.ShiftRightLogical)}<Int16>(Vector256<Int16><9>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"  firstOp: ({string.Join(", ", firstOp)})");
                 TestLibrary.TestFramework.LogInformation($"   result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ShiftRightLogical.Int16.16.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ShiftRightLogical.Int16.16.cs
index 02e7709fcfba..b9bd3d7257ce 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ShiftRightLogical.Int16.16.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ShiftRightLogical.Int16.16.cs
@@ -319,7 +319,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -327,7 +327,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -355,9 +360,11 @@ private void ValidateResult(void* firstOp, void* result, [CallerMemberName] stri
 
         private void ValidateResult(Int16[] firstOp, Int16[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (0 != result[0])
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -365,18 +372,20 @@ private void ValidateResult(Int16[] firstOp, Int16[] result, [CallerMemberName]
                 {
                     if (0 != result[i])
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Avx2)}.{nameof(Avx2.ShiftRightLogical)}<Int16>(Vector256<Int16><9>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"  firstOp: ({string.Join(", ", firstOp)})");
                 TestLibrary.TestFramework.LogInformation($"   result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ShiftRightLogical.Int32.1.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ShiftRightLogical.Int32.1.cs
index 816be27fdc86..e1a48cc4b4b9 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ShiftRightLogical.Int32.1.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ShiftRightLogical.Int32.1.cs
@@ -319,7 +319,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -327,7 +327,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -355,9 +360,11 @@ private void ValidateResult(void* firstOp, void* result, [CallerMemberName] stri
 
         private void ValidateResult(Int32[] firstOp, Int32[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if ((int)(firstOp[0] >> 1) != result[0])
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -365,18 +372,20 @@ private void ValidateResult(Int32[] firstOp, Int32[] result, [CallerMemberName]
                 {
                     if ((int)(firstOp[i] >> 1) != result[i])
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Avx2)}.{nameof(Avx2.ShiftRightLogical)}<Int32>(Vector256<Int32><9>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"  firstOp: ({string.Join(", ", firstOp)})");
                 TestLibrary.TestFramework.LogInformation($"   result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ShiftRightLogical.Int32.32.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ShiftRightLogical.Int32.32.cs
index bfbc26c5c37f..bf5f137cf49f 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ShiftRightLogical.Int32.32.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ShiftRightLogical.Int32.32.cs
@@ -319,7 +319,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -327,7 +327,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -355,9 +360,11 @@ private void ValidateResult(void* firstOp, void* result, [CallerMemberName] stri
 
         private void ValidateResult(Int32[] firstOp, Int32[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (0 != result[0])
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -365,18 +372,20 @@ private void ValidateResult(Int32[] firstOp, Int32[] result, [CallerMemberName]
                 {
                     if (0 != result[i])
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Avx2)}.{nameof(Avx2.ShiftRightLogical)}<Int32>(Vector256<Int32><9>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"  firstOp: ({string.Join(", ", firstOp)})");
                 TestLibrary.TestFramework.LogInformation($"   result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ShiftRightLogical.Int64.1.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ShiftRightLogical.Int64.1.cs
index 1ecff8eac009..ce3a00859360 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ShiftRightLogical.Int64.1.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ShiftRightLogical.Int64.1.cs
@@ -319,7 +319,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -327,7 +327,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -355,9 +360,11 @@ private void ValidateResult(void* firstOp, void* result, [CallerMemberName] stri
 
         private void ValidateResult(Int64[] firstOp, Int64[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if ((long)(firstOp[0] >> 1) != result[0])
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -365,18 +372,20 @@ private void ValidateResult(Int64[] firstOp, Int64[] result, [CallerMemberName]
                 {
                     if ((long)(firstOp[i] >> 1) != result[i])
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Avx2)}.{nameof(Avx2.ShiftRightLogical)}<Int64>(Vector256<Int64><9>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"  firstOp: ({string.Join(", ", firstOp)})");
                 TestLibrary.TestFramework.LogInformation($"   result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ShiftRightLogical.Int64.64.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ShiftRightLogical.Int64.64.cs
index c13fd14e6874..5050941fa4fd 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ShiftRightLogical.Int64.64.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ShiftRightLogical.Int64.64.cs
@@ -319,7 +319,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -327,7 +327,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -355,9 +360,11 @@ private void ValidateResult(void* firstOp, void* result, [CallerMemberName] stri
 
         private void ValidateResult(Int64[] firstOp, Int64[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (0 != result[0])
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -365,18 +372,20 @@ private void ValidateResult(Int64[] firstOp, Int64[] result, [CallerMemberName]
                 {
                     if (0 != result[i])
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Avx2)}.{nameof(Avx2.ShiftRightLogical)}<Int64>(Vector256<Int64><9>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"  firstOp: ({string.Join(", ", firstOp)})");
                 TestLibrary.TestFramework.LogInformation($"   result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ShiftRightLogical.UInt16.1.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ShiftRightLogical.UInt16.1.cs
index 63e75b62f2d4..260fe1e7f61d 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ShiftRightLogical.UInt16.1.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ShiftRightLogical.UInt16.1.cs
@@ -319,7 +319,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -327,7 +327,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -355,9 +360,11 @@ private void ValidateResult(void* firstOp, void* result, [CallerMemberName] stri
 
         private void ValidateResult(UInt16[] firstOp, UInt16[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if ((ushort)(firstOp[0] >> 1) != result[0])
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -365,18 +372,20 @@ private void ValidateResult(UInt16[] firstOp, UInt16[] result, [CallerMemberName
                 {
                     if ((ushort)(firstOp[i] >> 1) != result[i])
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Avx2)}.{nameof(Avx2.ShiftRightLogical)}<UInt16>(Vector256<UInt16><9>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"  firstOp: ({string.Join(", ", firstOp)})");
                 TestLibrary.TestFramework.LogInformation($"   result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ShiftRightLogical.UInt16.16.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ShiftRightLogical.UInt16.16.cs
index 95679e0f4a15..52a996cacc6a 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ShiftRightLogical.UInt16.16.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ShiftRightLogical.UInt16.16.cs
@@ -319,7 +319,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -327,7 +327,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -355,9 +360,11 @@ private void ValidateResult(void* firstOp, void* result, [CallerMemberName] stri
 
         private void ValidateResult(UInt16[] firstOp, UInt16[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (0 != result[0])
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -365,18 +372,20 @@ private void ValidateResult(UInt16[] firstOp, UInt16[] result, [CallerMemberName
                 {
                     if (0 != result[i])
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Avx2)}.{nameof(Avx2.ShiftRightLogical)}<UInt16>(Vector256<UInt16><9>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"  firstOp: ({string.Join(", ", firstOp)})");
                 TestLibrary.TestFramework.LogInformation($"   result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ShiftRightLogical.UInt32.1.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ShiftRightLogical.UInt32.1.cs
index 4c471013eedc..c0bc62f35f6e 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ShiftRightLogical.UInt32.1.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ShiftRightLogical.UInt32.1.cs
@@ -319,7 +319,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -327,7 +327,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -355,9 +360,11 @@ private void ValidateResult(void* firstOp, void* result, [CallerMemberName] stri
 
         private void ValidateResult(UInt32[] firstOp, UInt32[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if ((uint)(firstOp[0] >> 1) != result[0])
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -365,18 +372,20 @@ private void ValidateResult(UInt32[] firstOp, UInt32[] result, [CallerMemberName
                 {
                     if ((uint)(firstOp[i] >> 1) != result[i])
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Avx2)}.{nameof(Avx2.ShiftRightLogical)}<UInt32>(Vector256<UInt32><9>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"  firstOp: ({string.Join(", ", firstOp)})");
                 TestLibrary.TestFramework.LogInformation($"   result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ShiftRightLogical.UInt32.32.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ShiftRightLogical.UInt32.32.cs
index c6b08a6a555c..99002bf2e4ce 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ShiftRightLogical.UInt32.32.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ShiftRightLogical.UInt32.32.cs
@@ -319,7 +319,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -327,7 +327,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -355,9 +360,11 @@ private void ValidateResult(void* firstOp, void* result, [CallerMemberName] stri
 
         private void ValidateResult(UInt32[] firstOp, UInt32[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (0 != result[0])
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -365,18 +372,20 @@ private void ValidateResult(UInt32[] firstOp, UInt32[] result, [CallerMemberName
                 {
                     if (0!= result[i])
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Avx2)}.{nameof(Avx2.ShiftRightLogical)}<UInt32>(Vector256<UInt32><9>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"  firstOp: ({string.Join(", ", firstOp)})");
                 TestLibrary.TestFramework.LogInformation($"   result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ShiftRightLogical.UInt64.1.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ShiftRightLogical.UInt64.1.cs
index 8ab8ad6312c1..40283dad2479 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ShiftRightLogical.UInt64.1.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ShiftRightLogical.UInt64.1.cs
@@ -319,7 +319,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -327,7 +327,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -355,9 +360,11 @@ private void ValidateResult(void* firstOp, void* result, [CallerMemberName] stri
 
         private void ValidateResult(UInt64[] firstOp, UInt64[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if ((ulong)(firstOp[0] >> 1) != result[0])
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -365,18 +372,20 @@ private void ValidateResult(UInt64[] firstOp, UInt64[] result, [CallerMemberName
                 {
                     if ((ulong)(firstOp[i] >> 1) != result[i])
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Avx2)}.{nameof(Avx2.ShiftRightLogical)}<UInt64>(Vector256<UInt64><9>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"  firstOp: ({string.Join(", ", firstOp)})");
                 TestLibrary.TestFramework.LogInformation($"   result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ShiftRightLogical.UInt64.64.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ShiftRightLogical.UInt64.64.cs
index d49557904173..989b9364c576 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ShiftRightLogical.UInt64.64.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ShiftRightLogical.UInt64.64.cs
@@ -319,7 +319,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -327,7 +327,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -355,9 +360,11 @@ private void ValidateResult(void* firstOp, void* result, [CallerMemberName] stri
 
         private void ValidateResult(UInt64[] firstOp, UInt64[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (0 != result[0])
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -365,18 +372,20 @@ private void ValidateResult(UInt64[] firstOp, UInt64[] result, [CallerMemberName
                 {
                     if (0 != result[i])
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Avx2)}.{nameof(Avx2.ShiftRightLogical)}<UInt64>(Vector256<UInt64><9>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"  firstOp: ({string.Join(", ", firstOp)})");
                 TestLibrary.TestFramework.LogInformation($"   result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ShiftRightLogical128BitLane.Byte.1.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ShiftRightLogical128BitLane.Byte.1.cs
index e3b4ece72514..f2deec80be6a 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ShiftRightLogical128BitLane.Byte.1.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ShiftRightLogical128BitLane.Byte.1.cs
@@ -319,7 +319,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -327,7 +327,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -355,9 +360,11 @@ private void ValidateResult(void* firstOp, void* result, [CallerMemberName] stri
 
         private void ValidateResult(Byte[] firstOp, Byte[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (result[0] != 8)
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -365,18 +372,20 @@ private void ValidateResult(Byte[] firstOp, Byte[] result, [CallerMemberName] st
                 {
                     if ((i == 31 || i == 15 ? result[i] != 0 : result[i] != 8))
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Avx2)}.{nameof(Avx2.ShiftRightLogical128BitLane)}<Byte>(Vector256<Byte><9>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"  firstOp: ({string.Join(", ", firstOp)})");
                 TestLibrary.TestFramework.LogInformation($"   result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ShiftRightLogical128BitLane.Int16.1.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ShiftRightLogical128BitLane.Int16.1.cs
index e00a1e2e26d6..336d62a1f843 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ShiftRightLogical128BitLane.Int16.1.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ShiftRightLogical128BitLane.Int16.1.cs
@@ -319,7 +319,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -327,7 +327,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -355,9 +360,11 @@ private void ValidateResult(void* firstOp, void* result, [CallerMemberName] stri
 
         private void ValidateResult(Int16[] firstOp, Int16[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (result[0] != 2048)
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -365,18 +372,20 @@ private void ValidateResult(Int16[] firstOp, Int16[] result, [CallerMemberName]
                 {
                     if ((i == 7 || i == 15 ? result[i] != 0 : result[i] != 2048))
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Avx2)}.{nameof(Avx2.ShiftRightLogical128BitLane)}<Int16>(Vector256<Int16><9>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"  firstOp: ({string.Join(", ", firstOp)})");
                 TestLibrary.TestFramework.LogInformation($"   result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ShiftRightLogical128BitLane.Int32.1.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ShiftRightLogical128BitLane.Int32.1.cs
index 043aa70a96d8..d2af085de980 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ShiftRightLogical128BitLane.Int32.1.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ShiftRightLogical128BitLane.Int32.1.cs
@@ -319,7 +319,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -327,7 +327,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -355,9 +360,11 @@ private void ValidateResult(void* firstOp, void* result, [CallerMemberName] stri
 
         private void ValidateResult(Int32[] firstOp, Int32[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (result[0] != 134217728)
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -365,18 +372,20 @@ private void ValidateResult(Int32[] firstOp, Int32[] result, [CallerMemberName]
                 {
                     if ((i == 3 || i == 7 ? result[i] != 0 : result[i] != 134217728))
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Avx2)}.{nameof(Avx2.ShiftRightLogical128BitLane)}<Int32>(Vector256<Int32><9>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"  firstOp: ({string.Join(", ", firstOp)})");
                 TestLibrary.TestFramework.LogInformation($"   result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ShiftRightLogical128BitLane.Int64.1.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ShiftRightLogical128BitLane.Int64.1.cs
index b82237628d41..9feaf4e33e3c 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ShiftRightLogical128BitLane.Int64.1.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ShiftRightLogical128BitLane.Int64.1.cs
@@ -319,7 +319,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -327,7 +327,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -355,9 +360,11 @@ private void ValidateResult(void* firstOp, void* result, [CallerMemberName] stri
 
         private void ValidateResult(Int64[] firstOp, Int64[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (result[0] != 576460752303423488L)
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -365,18 +372,20 @@ private void ValidateResult(Int64[] firstOp, Int64[] result, [CallerMemberName]
                 {
                     if ((i == 2 ? result[i] != 576460752303423488L : result[i] != 0))
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Avx2)}.{nameof(Avx2.ShiftRightLogical128BitLane)}<Int64>(Vector256<Int64><9>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"  firstOp: ({string.Join(", ", firstOp)})");
                 TestLibrary.TestFramework.LogInformation($"   result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ShiftRightLogical128BitLane.SByte.1.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ShiftRightLogical128BitLane.SByte.1.cs
index 51e9e2d38e34..a93e6d063316 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ShiftRightLogical128BitLane.SByte.1.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ShiftRightLogical128BitLane.SByte.1.cs
@@ -319,7 +319,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -327,7 +327,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -355,9 +360,11 @@ private void ValidateResult(void* firstOp, void* result, [CallerMemberName] stri
 
         private void ValidateResult(SByte[] firstOp, SByte[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (result[0] != 8)
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -365,18 +372,20 @@ private void ValidateResult(SByte[] firstOp, SByte[] result, [CallerMemberName]
                 {
                     if ((i == 31 || i == 15 ? result[i] != 0 : result[i] != 8))
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Avx2)}.{nameof(Avx2.ShiftRightLogical128BitLane)}<SByte>(Vector256<SByte><9>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"  firstOp: ({string.Join(", ", firstOp)})");
                 TestLibrary.TestFramework.LogInformation($"   result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ShiftRightLogical128BitLane.UInt16.1.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ShiftRightLogical128BitLane.UInt16.1.cs
index 5bdaaed2558b..696753ddbe83 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ShiftRightLogical128BitLane.UInt16.1.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ShiftRightLogical128BitLane.UInt16.1.cs
@@ -319,7 +319,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -327,7 +327,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -355,9 +360,11 @@ private void ValidateResult(void* firstOp, void* result, [CallerMemberName] stri
 
         private void ValidateResult(UInt16[] firstOp, UInt16[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (result[0] != 2048)
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -365,18 +372,20 @@ private void ValidateResult(UInt16[] firstOp, UInt16[] result, [CallerMemberName
                 {
                     if ((i == 7 || i == 15 ? result[i] != 0 : result[i] != 2048))
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Avx2)}.{nameof(Avx2.ShiftRightLogical128BitLane)}<UInt16>(Vector256<UInt16><9>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"  firstOp: ({string.Join(", ", firstOp)})");
                 TestLibrary.TestFramework.LogInformation($"   result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ShiftRightLogical128BitLane.UInt32.1.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ShiftRightLogical128BitLane.UInt32.1.cs
index dd139de62ffd..380b56865123 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ShiftRightLogical128BitLane.UInt32.1.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ShiftRightLogical128BitLane.UInt32.1.cs
@@ -319,7 +319,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -327,7 +327,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -355,9 +360,11 @@ private void ValidateResult(void* firstOp, void* result, [CallerMemberName] stri
 
         private void ValidateResult(UInt32[] firstOp, UInt32[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (result[0] != 134217728)
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -365,18 +372,20 @@ private void ValidateResult(UInt32[] firstOp, UInt32[] result, [CallerMemberName
                 {
                     if ((i == 3 || i == 7 ? result[i] != 0 : result[i] != 134217728))
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Avx2)}.{nameof(Avx2.ShiftRightLogical128BitLane)}<UInt32>(Vector256<UInt32><9>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"  firstOp: ({string.Join(", ", firstOp)})");
                 TestLibrary.TestFramework.LogInformation($"   result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ShiftRightLogical128BitLane.UInt64.1.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ShiftRightLogical128BitLane.UInt64.1.cs
index 7db842bdf5bd..644b17e3ba85 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ShiftRightLogical128BitLane.UInt64.1.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ShiftRightLogical128BitLane.UInt64.1.cs
@@ -319,7 +319,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -327,7 +327,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -355,9 +360,11 @@ private void ValidateResult(void* firstOp, void* result, [CallerMemberName] stri
 
         private void ValidateResult(UInt64[] firstOp, UInt64[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (result[0] != 576460752303423488UL)
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -365,18 +372,20 @@ private void ValidateResult(UInt64[] firstOp, UInt64[] result, [CallerMemberName
                 {
                     if ((i == 2 ? result[i] != 576460752303423488UL : result[i] != 0))
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Avx2)}.{nameof(Avx2.ShiftRightLogical128BitLane)}<UInt64>(Vector256<UInt64><9>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"  firstOp: ({string.Join(", ", firstOp)})");
                 TestLibrary.TestFramework.LogInformation($"   result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Shuffle.Byte.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Shuffle.Byte.cs
index fb92fbbb14f8..3b896acbdb50 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Shuffle.Byte.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Shuffle.Byte.cs
@@ -334,7 +334,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -342,7 +342,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -374,9 +379,11 @@ private void ValidateResult(void* left, void* right, void* result, [CallerMember
 
         private void ValidateResult(Byte[] left, Byte[] right, Byte[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (result[0] != ((right[0] > 127) ? 0 : left[right[0] & 0x0F]))
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -384,19 +391,21 @@ private void ValidateResult(Byte[] left, Byte[] right, Byte[] result, [CallerMem
                 {
                     if (result[i] != (i < 16 ? (right[i] > 127 ? 0 : left[right[i] & 0x0F]) : (right[i] > 127 ? 0 : left[(right[i] & 0x0F) + 16])))
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Avx2)}.{nameof(Avx2.Shuffle)}<Byte>(Vector256<Byte>, Vector256<Byte>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Shuffle.Int32.1.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Shuffle.Int32.1.cs
index 136746326f57..923d578b8d74 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Shuffle.Int32.1.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Shuffle.Int32.1.cs
@@ -319,7 +319,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -327,7 +327,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -355,9 +360,11 @@ private void ValidateResult(void* firstOp, void* result, [CallerMemberName] stri
 
         private void ValidateResult(Int32[] firstOp, Int32[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (result[0] != firstOp[1])
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -365,18 +372,20 @@ private void ValidateResult(Int32[] firstOp, Int32[] result, [CallerMemberName]
                 {
                     if (result[i] != (i < 4 ? firstOp[0] : (i == 4 ? firstOp[5] : firstOp[4])))
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Avx2)}.{nameof(Avx2.Shuffle)}<Int32>(Vector256<Int32><9>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"  firstOp: ({string.Join(", ", firstOp)})");
                 TestLibrary.TestFramework.LogInformation($"   result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Shuffle.SByte.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Shuffle.SByte.cs
index d006c7e5254f..958ced518fd2 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Shuffle.SByte.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Shuffle.SByte.cs
@@ -334,7 +334,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -342,7 +342,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -374,9 +379,11 @@ private void ValidateResult(void* left, void* right, void* result, [CallerMember
 
         private void ValidateResult(SByte[] left, SByte[] right, SByte[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (result[0] != ((right[0] < 0) ? 0 : left[right[0] & 0x0F]))
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -384,19 +391,21 @@ private void ValidateResult(SByte[] left, SByte[] right, SByte[] result, [Caller
                 {
                     if (result[i] != (i < 16 ? (right[i] < 0 ? 0 : left[right[i] & 0x0F]) : (right[i] < 0 ? 0 : left[(right[i] & 0x0F) + 16])))
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Avx2)}.{nameof(Avx2.Shuffle)}<SByte>(Vector256<SByte>, Vector256<SByte>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Shuffle.UInt32.1.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Shuffle.UInt32.1.cs
index f6d545e285ef..210ec893c9e2 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Shuffle.UInt32.1.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Shuffle.UInt32.1.cs
@@ -319,7 +319,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -327,7 +327,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -355,9 +360,11 @@ private void ValidateResult(void* firstOp, void* result, [CallerMemberName] stri
 
         private void ValidateResult(UInt32[] firstOp, UInt32[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (result[0] != firstOp[1])
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -365,18 +372,20 @@ private void ValidateResult(UInt32[] firstOp, UInt32[] result, [CallerMemberName
                 {
                     if (result[i] != (i < 4 ? firstOp[0] : (i == 4 ? firstOp[5] : firstOp[4])))
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Avx2)}.{nameof(Avx2.Shuffle)}<UInt32>(Vector256<UInt32><9>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"  firstOp: ({string.Join(", ", firstOp)})");
                 TestLibrary.TestFramework.LogInformation($"   result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ShuffleHigh.Int16.228.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ShuffleHigh.Int16.228.cs
index ef17b8fba24b..aa8d7d3670b2 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ShuffleHigh.Int16.228.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ShuffleHigh.Int16.228.cs
@@ -319,7 +319,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -327,7 +327,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -355,9 +360,11 @@ private void ValidateResult(void* firstOp, void* result, [CallerMemberName] stri
 
         private void ValidateResult(Int16[] firstOp, Int16[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (result[0] != firstOp[0])
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -365,18 +372,20 @@ private void ValidateResult(Int16[] firstOp, Int16[] result, [CallerMemberName]
                 {
                     if (result[i] != firstOp[i])
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Avx2)}.{nameof(Avx2.ShuffleHigh)}<Int16>(Vector256<Int16><9>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"  firstOp: ({string.Join(", ", firstOp)})");
                 TestLibrary.TestFramework.LogInformation($"   result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ShuffleHigh.UInt16.228.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ShuffleHigh.UInt16.228.cs
index baafc6034456..20634795fb62 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ShuffleHigh.UInt16.228.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ShuffleHigh.UInt16.228.cs
@@ -319,7 +319,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -327,7 +327,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -355,9 +360,11 @@ private void ValidateResult(void* firstOp, void* result, [CallerMemberName] stri
 
         private void ValidateResult(UInt16[] firstOp, UInt16[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (result[0] != firstOp[0])
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -365,18 +372,20 @@ private void ValidateResult(UInt16[] firstOp, UInt16[] result, [CallerMemberName
                 {
                     if (result[i] != firstOp[i])
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Avx2)}.{nameof(Avx2.ShuffleHigh)}<UInt16>(Vector256<UInt16><9>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"  firstOp: ({string.Join(", ", firstOp)})");
                 TestLibrary.TestFramework.LogInformation($"   result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ShuffleLow.Int16.228.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ShuffleLow.Int16.228.cs
index 37aec02c9d1c..4949da8a84a0 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ShuffleLow.Int16.228.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ShuffleLow.Int16.228.cs
@@ -319,7 +319,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -327,7 +327,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -355,9 +360,11 @@ private void ValidateResult(void* firstOp, void* result, [CallerMemberName] stri
 
         private void ValidateResult(Int16[] firstOp, Int16[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (result[0] != firstOp[0])
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -365,18 +372,20 @@ private void ValidateResult(Int16[] firstOp, Int16[] result, [CallerMemberName]
                 {
                     if (result[i] != firstOp[i])
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Avx2)}.{nameof(Avx2.ShuffleLow)}<Int16>(Vector256<Int16><9>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"  firstOp: ({string.Join(", ", firstOp)})");
                 TestLibrary.TestFramework.LogInformation($"   result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ShuffleLow.UInt16.228.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ShuffleLow.UInt16.228.cs
index 5b81d54072e3..9e3e630c1946 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ShuffleLow.UInt16.228.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ShuffleLow.UInt16.228.cs
@@ -319,7 +319,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -327,7 +327,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -355,9 +360,11 @@ private void ValidateResult(void* firstOp, void* result, [CallerMemberName] stri
 
         private void ValidateResult(UInt16[] firstOp, UInt16[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (result[0] != firstOp[0])
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -365,18 +372,20 @@ private void ValidateResult(UInt16[] firstOp, UInt16[] result, [CallerMemberName
                 {
                     if (result[i] != firstOp[i])
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Avx2)}.{nameof(Avx2.ShuffleLow)}<UInt16>(Vector256<UInt16><9>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"  firstOp: ({string.Join(", ", firstOp)})");
                 TestLibrary.TestFramework.LogInformation($"   result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Sign.Int16.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Sign.Int16.cs
index 7a363c8634b5..c05c276b3701 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Sign.Int16.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Sign.Int16.cs
@@ -334,7 +334,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -342,7 +342,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -374,9 +379,11 @@ private void ValidateResult(void* left, void* right, void* result, [CallerMember
 
         private void ValidateResult(Int16[] left, Int16[] right, Int16[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (result[0] != (right[0] < 0 ? (short)(-left[0]) : (right[0] > 0 ? left[0] : 0)))
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -384,19 +391,21 @@ private void ValidateResult(Int16[] left, Int16[] right, Int16[] result, [Caller
                 {
                     if (result[i] != (right[i] < 0 ? (short)(-left[i]) : (right[i] > 0 ? left[i] : 0)))
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Avx2)}.{nameof(Avx2.Sign)}<Int16>(Vector256<Int16>, Vector256<Int16>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Sign.Int32.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Sign.Int32.cs
index a3e92d8d6362..ac66dd14a00c 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Sign.Int32.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Sign.Int32.cs
@@ -334,7 +334,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -342,7 +342,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -374,9 +379,11 @@ private void ValidateResult(void* left, void* right, void* result, [CallerMember
 
         private void ValidateResult(Int32[] left, Int32[] right, Int32[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (result[0] != (right[0] < 0 ? (int)(-left[0]) : (right[0] > 0 ? left[0] : 0)))
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -384,19 +391,21 @@ private void ValidateResult(Int32[] left, Int32[] right, Int32[] result, [Caller
                 {
                     if (result[i] != (right[i] < 0 ? (int)(-left[i]) : (right[i] > 0 ? left[i] : 0)))
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Avx2)}.{nameof(Avx2.Sign)}<Int32>(Vector256<Int32>, Vector256<Int32>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Sign.SByte.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Sign.SByte.cs
index ab44e0d90204..8803628e3465 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Sign.SByte.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Sign.SByte.cs
@@ -334,7 +334,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -342,7 +342,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -374,9 +379,11 @@ private void ValidateResult(void* left, void* right, void* result, [CallerMember
 
         private void ValidateResult(SByte[] left, SByte[] right, SByte[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (result[0] != (right[0] < 0 ? (sbyte)(-left[0]) : (right[0] > 0 ? left[0] : 0)))
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -384,19 +391,21 @@ private void ValidateResult(SByte[] left, SByte[] right, SByte[] result, [Caller
                 {
                     if (result[i] != (right[i] < 0 ? (sbyte)(-left[i]) : (right[i] > 0 ? left[i] : 0)))
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Avx2)}.{nameof(Avx2.Sign)}<SByte>(Vector256<SByte>, Vector256<SByte>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Subtract.Byte.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Subtract.Byte.cs
index 3e43dd675fec..53e73564ca9d 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Subtract.Byte.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Subtract.Byte.cs
@@ -334,7 +334,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -342,7 +342,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -374,9 +379,11 @@ private void ValidateResult(void* left, void* right, void* result, [CallerMember
 
         private void ValidateResult(Byte[] left, Byte[] right, Byte[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if ((byte)(left[0] - right[0]) != result[0])
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -384,19 +391,21 @@ private void ValidateResult(Byte[] left, Byte[] right, Byte[] result, [CallerMem
                 {
                     if ((byte)(left[i] - right[i]) != result[i])
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Avx2)}.{nameof(Avx2.Subtract)}<Byte>(Vector256<Byte>, Vector256<Byte>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Subtract.Int16.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Subtract.Int16.cs
index dc7722e791ef..97e1e72c5095 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Subtract.Int16.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Subtract.Int16.cs
@@ -334,7 +334,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -342,7 +342,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -374,9 +379,11 @@ private void ValidateResult(void* left, void* right, void* result, [CallerMember
 
         private void ValidateResult(Int16[] left, Int16[] right, Int16[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if ((short)(left[0] - right[0]) != result[0])
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -384,19 +391,21 @@ private void ValidateResult(Int16[] left, Int16[] right, Int16[] result, [Caller
                 {
                     if ((short)(left[i] - right[i]) != result[i])
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Avx2)}.{nameof(Avx2.Subtract)}<Int16>(Vector256<Int16>, Vector256<Int16>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Subtract.Int32.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Subtract.Int32.cs
index 617108529cbc..fe9d04657776 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Subtract.Int32.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Subtract.Int32.cs
@@ -334,7 +334,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -342,7 +342,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -374,9 +379,11 @@ private void ValidateResult(void* left, void* right, void* result, [CallerMember
 
         private void ValidateResult(Int32[] left, Int32[] right, Int32[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if ((int)(left[0] - right[0]) != result[0])
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -384,19 +391,21 @@ private void ValidateResult(Int32[] left, Int32[] right, Int32[] result, [Caller
                 {
                     if ((int)(left[i] - right[i]) != result[i])
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Avx2)}.{nameof(Avx2.Subtract)}<Int32>(Vector256<Int32>, Vector256<Int32>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Subtract.Int64.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Subtract.Int64.cs
index 3b5b14ab178a..29426ee45fe5 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Subtract.Int64.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Subtract.Int64.cs
@@ -334,7 +334,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -342,7 +342,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -374,9 +379,11 @@ private void ValidateResult(void* left, void* right, void* result, [CallerMember
 
         private void ValidateResult(Int64[] left, Int64[] right, Int64[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if ((long)(left[0] - right[0]) != result[0])
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -384,19 +391,21 @@ private void ValidateResult(Int64[] left, Int64[] right, Int64[] result, [Caller
                 {
                     if ((long)(left[i] - right[i]) != result[i])
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Avx2)}.{nameof(Avx2.Subtract)}<Int64>(Vector256<Int64>, Vector256<Int64>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Subtract.SByte.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Subtract.SByte.cs
index 0813bcd6829c..e2a2ada93e84 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Subtract.SByte.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Subtract.SByte.cs
@@ -334,7 +334,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -342,7 +342,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -374,9 +379,11 @@ private void ValidateResult(void* left, void* right, void* result, [CallerMember
 
         private void ValidateResult(SByte[] left, SByte[] right, SByte[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if ((sbyte)(left[0] - right[0]) != result[0])
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -384,19 +391,21 @@ private void ValidateResult(SByte[] left, SByte[] right, SByte[] result, [Caller
                 {
                     if ((sbyte)(left[i] - right[i]) != result[i])
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Avx2)}.{nameof(Avx2.Subtract)}<SByte>(Vector256<SByte>, Vector256<SByte>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Subtract.UInt16.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Subtract.UInt16.cs
index 0f9d5ef5d7d2..745ac9aa7449 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Subtract.UInt16.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Subtract.UInt16.cs
@@ -334,7 +334,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -342,7 +342,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -374,9 +379,11 @@ private void ValidateResult(void* left, void* right, void* result, [CallerMember
 
         private void ValidateResult(UInt16[] left, UInt16[] right, UInt16[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if ((ushort)(left[0] - right[0]) != result[0])
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -384,19 +391,21 @@ private void ValidateResult(UInt16[] left, UInt16[] right, UInt16[] result, [Cal
                 {
                     if ((ushort)(left[i] - right[i]) != result[i])
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Avx2)}.{nameof(Avx2.Subtract)}<UInt16>(Vector256<UInt16>, Vector256<UInt16>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Subtract.UInt32.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Subtract.UInt32.cs
index aaa71a6333f4..eedf5a41cc79 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Subtract.UInt32.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Subtract.UInt32.cs
@@ -334,7 +334,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -342,7 +342,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -374,9 +379,11 @@ private void ValidateResult(void* left, void* right, void* result, [CallerMember
 
         private void ValidateResult(UInt32[] left, UInt32[] right, UInt32[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if ((uint)(left[0] - right[0]) != result[0])
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -384,19 +391,21 @@ private void ValidateResult(UInt32[] left, UInt32[] right, UInt32[] result, [Cal
                 {
                     if ((uint)(left[i] - right[i]) != result[i])
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Avx2)}.{nameof(Avx2.Subtract)}<UInt32>(Vector256<UInt32>, Vector256<UInt32>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Subtract.UInt64.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Subtract.UInt64.cs
index 42a42bb57307..78b53ac3c01d 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Subtract.UInt64.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Subtract.UInt64.cs
@@ -334,7 +334,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -342,7 +342,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -374,9 +379,11 @@ private void ValidateResult(void* left, void* right, void* result, [CallerMember
 
         private void ValidateResult(UInt64[] left, UInt64[] right, UInt64[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if ((ulong)(left[0] - right[0]) != result[0])
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -384,19 +391,21 @@ private void ValidateResult(UInt64[] left, UInt64[] right, UInt64[] result, [Cal
                 {
                     if ((ulong)(left[i] - right[i]) != result[i])
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Avx2)}.{nameof(Avx2.Subtract)}<UInt64>(Vector256<UInt64>, Vector256<UInt64>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/SumAbsoluteDifferences.UInt16.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/SumAbsoluteDifferences.UInt16.cs
index fbe5beb40343..95f279deef0e 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/SumAbsoluteDifferences.UInt16.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/SumAbsoluteDifferences.UInt16.cs
@@ -334,7 +334,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -342,7 +342,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -374,9 +379,11 @@ private void ValidateResult(void* left, void* right, void* result, [CallerMember
 
         private void ValidateResult(Byte[] left, Byte[] right, UInt16[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (result[0] != Math.Abs(left[0] - right[0]) + Math.Abs(left[1] - right[1]) + Math.Abs(left[2] - right[2]) + Math.Abs(left[3] - right[3]) + Math.Abs(left[4] - right[4]) + Math.Abs(left[5] - right[5]) + Math.Abs(left[6] - right[6]) + Math.Abs(left[7] - right[7]))
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -384,19 +391,21 @@ private void ValidateResult(Byte[] left, Byte[] right, UInt16[] result, [CallerM
                 {
                     if (result[i] != ((i % 4 != 0) ? 0 : Math.Abs(left[(i/4)*8] - right[(i/4)*8]) + Math.Abs(left[(i/4)*8+1] - right[(i/4)*8+1]) + Math.Abs(left[(i/4)*8+2] - right[(i/4)*8+2]) + Math.Abs(left[(i/4)*8+3] - right[(i/4)*8+3]) + Math.Abs(left[(i/4)*8+4] - right[(i/4)*8+4]) + Math.Abs(left[(i/4)*8+5] - right[(i/4)*8+5]) + Math.Abs(left[(i/4)*8+6] - right[(i/4)*8+6]) + Math.Abs(left[(i/4)*8+7] - right[(i/4)*8+7])))
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Avx2)}.{nameof(Avx2.SumAbsoluteDifferences)}<UInt16>(Vector256<Byte>, Vector256<Byte>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Xor.Byte.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Xor.Byte.cs
index caf75ce3c17c..94e668f53a1e 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Xor.Byte.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Xor.Byte.cs
@@ -334,7 +334,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -342,7 +342,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -374,9 +379,11 @@ private void ValidateResult(void* left, void* right, void* result, [CallerMember
 
         private void ValidateResult(Byte[] left, Byte[] right, Byte[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if ((byte)(left[0] ^ right[0]) != result[0])
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -384,19 +391,21 @@ private void ValidateResult(Byte[] left, Byte[] right, Byte[] result, [CallerMem
                 {
                     if ((byte)(left[i] ^ right[i]) != result[i])
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Avx2)}.{nameof(Avx2.Xor)}<Byte>(Vector256<Byte>, Vector256<Byte>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Xor.Int16.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Xor.Int16.cs
index 63bf5c1f3559..cb1f13d2ac47 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Xor.Int16.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Xor.Int16.cs
@@ -334,7 +334,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -342,7 +342,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -374,9 +379,11 @@ private void ValidateResult(void* left, void* right, void* result, [CallerMember
 
         private void ValidateResult(Int16[] left, Int16[] right, Int16[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if ((short)(left[0] ^ right[0]) != result[0])
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -384,19 +391,21 @@ private void ValidateResult(Int16[] left, Int16[] right, Int16[] result, [Caller
                 {
                     if ((short)(left[i] ^ right[i]) != result[i])
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Avx2)}.{nameof(Avx2.Xor)}<Int16>(Vector256<Int16>, Vector256<Int16>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Xor.Int32.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Xor.Int32.cs
index 6d23e23e984f..6487c3956d9c 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Xor.Int32.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Xor.Int32.cs
@@ -334,7 +334,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -342,7 +342,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -374,9 +379,11 @@ private void ValidateResult(void* left, void* right, void* result, [CallerMember
 
         private void ValidateResult(Int32[] left, Int32[] right, Int32[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if ((int)(left[0] ^ right[0]) != result[0])
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -384,19 +391,21 @@ private void ValidateResult(Int32[] left, Int32[] right, Int32[] result, [Caller
                 {
                     if ((int)(left[i] ^ right[i]) != result[i])
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Avx2)}.{nameof(Avx2.Xor)}<Int32>(Vector256<Int32>, Vector256<Int32>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Xor.Int64.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Xor.Int64.cs
index 12bb07c8296c..8ee5f9400fd6 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Xor.Int64.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Xor.Int64.cs
@@ -334,7 +334,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -342,7 +342,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -374,9 +379,11 @@ private void ValidateResult(void* left, void* right, void* result, [CallerMember
 
         private void ValidateResult(Int64[] left, Int64[] right, Int64[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if ((long)(left[0] ^ right[0]) != result[0])
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -384,19 +391,21 @@ private void ValidateResult(Int64[] left, Int64[] right, Int64[] result, [Caller
                 {
                     if ((long)(left[i] ^ right[i]) != result[i])
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Avx2)}.{nameof(Avx2.Xor)}<Int64>(Vector256<Int64>, Vector256<Int64>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Xor.SByte.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Xor.SByte.cs
index c33e8cd42824..2be418a4b274 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Xor.SByte.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Xor.SByte.cs
@@ -334,7 +334,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -342,7 +342,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -374,9 +379,11 @@ private void ValidateResult(void* left, void* right, void* result, [CallerMember
 
         private void ValidateResult(SByte[] left, SByte[] right, SByte[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if ((sbyte)(left[0] ^ right[0]) != result[0])
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -384,19 +391,21 @@ private void ValidateResult(SByte[] left, SByte[] right, SByte[] result, [Caller
                 {
                     if ((sbyte)(left[i] ^ right[i]) != result[i])
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Avx2)}.{nameof(Avx2.Xor)}<SByte>(Vector256<SByte>, Vector256<SByte>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Xor.UInt16.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Xor.UInt16.cs
index 15d22585584b..712199999197 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Xor.UInt16.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Xor.UInt16.cs
@@ -334,7 +334,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -342,7 +342,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -374,9 +379,11 @@ private void ValidateResult(void* left, void* right, void* result, [CallerMember
 
         private void ValidateResult(UInt16[] left, UInt16[] right, UInt16[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if ((ushort)(left[0] ^ right[0]) != result[0])
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -384,19 +391,21 @@ private void ValidateResult(UInt16[] left, UInt16[] right, UInt16[] result, [Cal
                 {
                     if ((ushort)(left[i] ^ right[i]) != result[i])
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Avx2)}.{nameof(Avx2.Xor)}<UInt16>(Vector256<UInt16>, Vector256<UInt16>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Xor.UInt32.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Xor.UInt32.cs
index a634971d3bc9..55f4dd367f23 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Xor.UInt32.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Xor.UInt32.cs
@@ -334,7 +334,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -342,7 +342,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -374,9 +379,11 @@ private void ValidateResult(void* left, void* right, void* result, [CallerMember
 
         private void ValidateResult(UInt32[] left, UInt32[] right, UInt32[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if ((uint)(left[0] ^ right[0]) != result[0])
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -384,19 +391,21 @@ private void ValidateResult(UInt32[] left, UInt32[] right, UInt32[] result, [Cal
                 {
                     if ((uint)(left[i] ^ right[i]) != result[i])
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Avx2)}.{nameof(Avx2.Xor)}<UInt32>(Vector256<UInt32>, Vector256<UInt32>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Xor.UInt64.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Xor.UInt64.cs
index 71ea147f1bea..27c3c2234815 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Xor.UInt64.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Xor.UInt64.cs
@@ -334,7 +334,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -342,7 +342,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -374,9 +379,11 @@ private void ValidateResult(void* left, void* right, void* result, [CallerMember
 
         private void ValidateResult(UInt64[] left, UInt64[] right, UInt64[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if ((ulong)(left[0] ^ right[0]) != result[0])
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -384,19 +391,21 @@ private void ValidateResult(UInt64[] left, UInt64[] right, UInt64[] result, [Cal
                 {
                     if ((ulong)(left[i] ^ right[i]) != result[i])
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Avx2)}.{nameof(Avx2.Xor)}<UInt64>(Vector256<UInt64>, Vector256<UInt64>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx2_Vector128/Blend.Int32.1.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx2_Vector128/Blend.Int32.1.cs
index a854f9eb13c6..5e717770abf4 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Avx2_Vector128/Blend.Int32.1.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx2_Vector128/Blend.Int32.1.cs
@@ -341,7 +341,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -349,7 +349,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -381,9 +386,11 @@ private void ValidateResult(void* left, void* right, void* result, [CallerMember
 
         private void ValidateResult(Int32[] left, Int32[] right, Int32[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (result[0] != (((1 & (1 << 0)) == 0) ? left[0] : right[0]))
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -391,19 +398,21 @@ private void ValidateResult(Int32[] left, Int32[] right, Int32[] result, [Caller
                 {
                     if (result[i] != (((1 & (1 << i)) == 0) ? left[i] : right[i]))
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Avx2)}.{nameof(Avx2.Blend)}<Int32>(Vector128<Int32>.1, Vector128<Int32>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx2_Vector128/Blend.Int32.2.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx2_Vector128/Blend.Int32.2.cs
index a8f974e27995..6725be4caec1 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Avx2_Vector128/Blend.Int32.2.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx2_Vector128/Blend.Int32.2.cs
@@ -341,7 +341,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -349,7 +349,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -381,9 +386,11 @@ private void ValidateResult(void* left, void* right, void* result, [CallerMember
 
         private void ValidateResult(Int32[] left, Int32[] right, Int32[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (result[0] != (((2 & (1 << 0)) == 0) ? left[0] : right[0]))
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -391,19 +398,21 @@ private void ValidateResult(Int32[] left, Int32[] right, Int32[] result, [Caller
                 {
                     if (result[i] != (((2 & (1 << i)) == 0) ? left[i] : right[i]))
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Avx2)}.{nameof(Avx2.Blend)}<Int32>(Vector128<Int32>.2, Vector128<Int32>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx2_Vector128/Blend.Int32.4.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx2_Vector128/Blend.Int32.4.cs
index c80fa33706b1..4462e98de69b 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Avx2_Vector128/Blend.Int32.4.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx2_Vector128/Blend.Int32.4.cs
@@ -341,7 +341,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -349,7 +349,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -381,9 +386,11 @@ private void ValidateResult(void* left, void* right, void* result, [CallerMember
 
         private void ValidateResult(Int32[] left, Int32[] right, Int32[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (result[0] != (((4 & (1 << 0)) == 0) ? left[0] : right[0]))
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -391,19 +398,21 @@ private void ValidateResult(Int32[] left, Int32[] right, Int32[] result, [Caller
                 {
                     if (result[i] != (((4 & (1 << i)) == 0) ? left[i] : right[i]))
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Avx2)}.{nameof(Avx2.Blend)}<Int32>(Vector128<Int32>.4, Vector128<Int32>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx2_Vector128/Blend.Int32.85.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx2_Vector128/Blend.Int32.85.cs
index 5b0c176364b6..b6dfdc8ef607 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Avx2_Vector128/Blend.Int32.85.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx2_Vector128/Blend.Int32.85.cs
@@ -341,7 +341,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -349,7 +349,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -381,9 +386,11 @@ private void ValidateResult(void* left, void* right, void* result, [CallerMember
 
         private void ValidateResult(Int32[] left, Int32[] right, Int32[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (result[0] != (((85 & (1 << 0)) == 0) ? left[0] : right[0]))
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -391,19 +398,21 @@ private void ValidateResult(Int32[] left, Int32[] right, Int32[] result, [Caller
                 {
                     if (result[i] != (((85 & (1 << i)) == 0) ? left[i] : right[i]))
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Avx2)}.{nameof(Avx2.Blend)}<Int32>(Vector128<Int32>.85, Vector128<Int32>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx2_Vector128/Blend.UInt32.1.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx2_Vector128/Blend.UInt32.1.cs
index 17fb0b9693d8..836ff7f09842 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Avx2_Vector128/Blend.UInt32.1.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx2_Vector128/Blend.UInt32.1.cs
@@ -341,7 +341,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -349,7 +349,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -381,9 +386,11 @@ private void ValidateResult(void* left, void* right, void* result, [CallerMember
 
         private void ValidateResult(UInt32[] left, UInt32[] right, UInt32[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (result[0] != (((1 & (1 << 0)) == 0) ? left[0] : right[0]))
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -391,19 +398,21 @@ private void ValidateResult(UInt32[] left, UInt32[] right, UInt32[] result, [Cal
                 {
                     if (result[i] != (((1 & (1 << i)) == 0) ? left[i] : right[i]))
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Avx2)}.{nameof(Avx2.Blend)}<UInt32>(Vector128<UInt32>.1, Vector128<UInt32>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx2_Vector128/Blend.UInt32.2.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx2_Vector128/Blend.UInt32.2.cs
index 88bb39744356..fe38fa2549f2 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Avx2_Vector128/Blend.UInt32.2.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx2_Vector128/Blend.UInt32.2.cs
@@ -341,7 +341,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -349,7 +349,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -381,9 +386,11 @@ private void ValidateResult(void* left, void* right, void* result, [CallerMember
 
         private void ValidateResult(UInt32[] left, UInt32[] right, UInt32[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (result[0] != (((2 & (1 << 0)) == 0) ? left[0] : right[0]))
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -391,19 +398,21 @@ private void ValidateResult(UInt32[] left, UInt32[] right, UInt32[] result, [Cal
                 {
                     if (result[i] != (((2 & (1 << i)) == 0) ? left[i] : right[i]))
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Avx2)}.{nameof(Avx2.Blend)}<UInt32>(Vector128<UInt32>.2, Vector128<UInt32>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx2_Vector128/Blend.UInt32.4.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx2_Vector128/Blend.UInt32.4.cs
index 30e09962244a..021de97086ca 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Avx2_Vector128/Blend.UInt32.4.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx2_Vector128/Blend.UInt32.4.cs
@@ -341,7 +341,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -349,7 +349,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -381,9 +386,11 @@ private void ValidateResult(void* left, void* right, void* result, [CallerMember
 
         private void ValidateResult(UInt32[] left, UInt32[] right, UInt32[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (result[0] != (((4 & (1 << 0)) == 0) ? left[0] : right[0]))
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -391,19 +398,21 @@ private void ValidateResult(UInt32[] left, UInt32[] right, UInt32[] result, [Cal
                 {
                     if (result[i] != (((4 & (1 << i)) == 0) ? left[i] : right[i]))
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Avx2)}.{nameof(Avx2.Blend)}<UInt32>(Vector128<UInt32>.4, Vector128<UInt32>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx2_Vector128/Blend.UInt32.85.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx2_Vector128/Blend.UInt32.85.cs
index 6ccc1470a7ea..06d7db2239e0 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Avx2_Vector128/Blend.UInt32.85.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx2_Vector128/Blend.UInt32.85.cs
@@ -341,7 +341,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -349,7 +349,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -381,9 +386,11 @@ private void ValidateResult(void* left, void* right, void* result, [CallerMember
 
         private void ValidateResult(UInt32[] left, UInt32[] right, UInt32[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (result[0] != (((85 & (1 << 0)) == 0) ? left[0] : right[0]))
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -391,19 +398,21 @@ private void ValidateResult(UInt32[] left, UInt32[] right, UInt32[] result, [Cal
                 {
                     if (result[i] != (((85 & (1 << i)) == 0) ? left[i] : right[i]))
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Avx2)}.{nameof(Avx2.Blend)}<UInt32>(Vector128<UInt32>.85, Vector128<UInt32>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx2_Vector128/BroadcastScalarToVector128.Byte.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx2_Vector128/BroadcastScalarToVector128.Byte.cs
index b1d3e1492f04..e3d126e34aab 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Avx2_Vector128/BroadcastScalarToVector128.Byte.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx2_Vector128/BroadcastScalarToVector128.Byte.cs
@@ -133,9 +133,11 @@ private void ValidateResult(void* firstOp, void* result, [CallerMemberName] stri
 
         private void ValidateResult(Byte[] firstOp, Byte[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (firstOp[0] != result[0])
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -143,18 +145,20 @@ private void ValidateResult(Byte[] firstOp, Byte[] result, [CallerMemberName] st
                 {
                     if ((firstOp[0] != result[i]))
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Avx2)}.{nameof(Avx2.BroadcastScalarToVector128)}<Byte>(Vector128<Byte>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"  firstOp: ({string.Join(", ", firstOp)})");
                 TestLibrary.TestFramework.LogInformation($"   result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx2_Vector128/BroadcastScalarToVector128.Int16.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx2_Vector128/BroadcastScalarToVector128.Int16.cs
index d5d4f0cdf421..684e0f5765a2 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Avx2_Vector128/BroadcastScalarToVector128.Int16.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx2_Vector128/BroadcastScalarToVector128.Int16.cs
@@ -133,9 +133,11 @@ private void ValidateResult(void* firstOp, void* result, [CallerMemberName] stri
 
         private void ValidateResult(Int16[] firstOp, Int16[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (firstOp[0] != result[0])
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -143,18 +145,20 @@ private void ValidateResult(Int16[] firstOp, Int16[] result, [CallerMemberName]
                 {
                     if ((firstOp[0] != result[i]))
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Avx2)}.{nameof(Avx2.BroadcastScalarToVector128)}<Int16>(Vector128<Int16>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"  firstOp: ({string.Join(", ", firstOp)})");
                 TestLibrary.TestFramework.LogInformation($"   result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx2_Vector128/BroadcastScalarToVector128.Int32.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx2_Vector128/BroadcastScalarToVector128.Int32.cs
index 3a6c05b60bc3..0c699c6763fa 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Avx2_Vector128/BroadcastScalarToVector128.Int32.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx2_Vector128/BroadcastScalarToVector128.Int32.cs
@@ -133,9 +133,11 @@ private void ValidateResult(void* firstOp, void* result, [CallerMemberName] stri
 
         private void ValidateResult(Int32[] firstOp, Int32[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (firstOp[0] != result[0])
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -143,18 +145,20 @@ private void ValidateResult(Int32[] firstOp, Int32[] result, [CallerMemberName]
                 {
                     if ((firstOp[0] != result[i]))
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Avx2)}.{nameof(Avx2.BroadcastScalarToVector128)}<Int32>(Vector128<Int32>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"  firstOp: ({string.Join(", ", firstOp)})");
                 TestLibrary.TestFramework.LogInformation($"   result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx2_Vector128/BroadcastScalarToVector128.Int64.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx2_Vector128/BroadcastScalarToVector128.Int64.cs
index fc034f3495c6..78ed3929796c 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Avx2_Vector128/BroadcastScalarToVector128.Int64.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx2_Vector128/BroadcastScalarToVector128.Int64.cs
@@ -133,9 +133,11 @@ private void ValidateResult(void* firstOp, void* result, [CallerMemberName] stri
 
         private void ValidateResult(Int64[] firstOp, Int64[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (firstOp[0] != result[0])
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -143,18 +145,20 @@ private void ValidateResult(Int64[] firstOp, Int64[] result, [CallerMemberName]
                 {
                     if ((firstOp[0] != result[i]))
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Avx2)}.{nameof(Avx2.BroadcastScalarToVector128)}<Int64>(Vector128<Int64>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"  firstOp: ({string.Join(", ", firstOp)})");
                 TestLibrary.TestFramework.LogInformation($"   result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx2_Vector128/BroadcastScalarToVector128.SByte.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx2_Vector128/BroadcastScalarToVector128.SByte.cs
index 2f57a44514c1..1e64204e502c 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Avx2_Vector128/BroadcastScalarToVector128.SByte.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx2_Vector128/BroadcastScalarToVector128.SByte.cs
@@ -133,9 +133,11 @@ private void ValidateResult(void* firstOp, void* result, [CallerMemberName] stri
 
         private void ValidateResult(SByte[] firstOp, SByte[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (firstOp[0] != result[0])
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -143,18 +145,20 @@ private void ValidateResult(SByte[] firstOp, SByte[] result, [CallerMemberName]
                 {
                     if ((firstOp[0] != result[i]))
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Avx2)}.{nameof(Avx2.BroadcastScalarToVector128)}<SByte>(Vector128<SByte>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"  firstOp: ({string.Join(", ", firstOp)})");
                 TestLibrary.TestFramework.LogInformation($"   result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx2_Vector128/BroadcastScalarToVector128.UInt16.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx2_Vector128/BroadcastScalarToVector128.UInt16.cs
index 6d655f70f15b..73e296c711c8 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Avx2_Vector128/BroadcastScalarToVector128.UInt16.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx2_Vector128/BroadcastScalarToVector128.UInt16.cs
@@ -133,9 +133,11 @@ private void ValidateResult(void* firstOp, void* result, [CallerMemberName] stri
 
         private void ValidateResult(UInt16[] firstOp, UInt16[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (firstOp[0] != result[0])
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -143,18 +145,20 @@ private void ValidateResult(UInt16[] firstOp, UInt16[] result, [CallerMemberName
                 {
                     if ((firstOp[0] != result[i]))
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Avx2)}.{nameof(Avx2.BroadcastScalarToVector128)}<UInt16>(Vector128<UInt16>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"  firstOp: ({string.Join(", ", firstOp)})");
                 TestLibrary.TestFramework.LogInformation($"   result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx2_Vector128/BroadcastScalarToVector128.UInt32.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx2_Vector128/BroadcastScalarToVector128.UInt32.cs
index 01851f5418f6..d69743b75dd2 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Avx2_Vector128/BroadcastScalarToVector128.UInt32.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx2_Vector128/BroadcastScalarToVector128.UInt32.cs
@@ -133,9 +133,11 @@ private void ValidateResult(void* firstOp, void* result, [CallerMemberName] stri
 
         private void ValidateResult(UInt32[] firstOp, UInt32[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (firstOp[0] != result[0])
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -143,18 +145,20 @@ private void ValidateResult(UInt32[] firstOp, UInt32[] result, [CallerMemberName
                 {
                     if ((firstOp[0] != result[i]))
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Avx2)}.{nameof(Avx2.BroadcastScalarToVector128)}<UInt32>(Vector128<UInt32>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"  firstOp: ({string.Join(", ", firstOp)})");
                 TestLibrary.TestFramework.LogInformation($"   result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx2_Vector128/BroadcastScalarToVector128.UInt64.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx2_Vector128/BroadcastScalarToVector128.UInt64.cs
index 8eacca863bb7..89cd9163da9d 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Avx2_Vector128/BroadcastScalarToVector128.UInt64.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx2_Vector128/BroadcastScalarToVector128.UInt64.cs
@@ -133,9 +133,11 @@ private void ValidateResult(void* firstOp, void* result, [CallerMemberName] stri
 
         private void ValidateResult(UInt64[] firstOp, UInt64[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (firstOp[0] != result[0])
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -143,18 +145,20 @@ private void ValidateResult(UInt64[] firstOp, UInt64[] result, [CallerMemberName
                 {
                     if ((firstOp[0] != result[i]))
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Avx2)}.{nameof(Avx2.BroadcastScalarToVector128)}<UInt64>(Vector128<UInt64>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"  firstOp: ({string.Join(", ", firstOp)})");
                 TestLibrary.TestFramework.LogInformation($"   result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx2_Vector128/BroadcastScalarToVector256.Byte.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx2_Vector128/BroadcastScalarToVector256.Byte.cs
index 25318694d66a..bfdacccffa69 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Avx2_Vector128/BroadcastScalarToVector256.Byte.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx2_Vector128/BroadcastScalarToVector256.Byte.cs
@@ -133,9 +133,11 @@ private void ValidateResult(void* firstOp, void* result, [CallerMemberName] stri
 
         private void ValidateResult(Byte[] firstOp, Byte[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (firstOp[0] != result[0])
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -143,18 +145,20 @@ private void ValidateResult(Byte[] firstOp, Byte[] result, [CallerMemberName] st
                 {
                     if ((firstOp[0] != result[i]))
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Avx2)}.{nameof(Avx2.BroadcastScalarToVector256)}<Byte>(Vector128<Byte>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"  firstOp: ({string.Join(", ", firstOp)})");
                 TestLibrary.TestFramework.LogInformation($"   result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx2_Vector128/BroadcastScalarToVector256.Int16.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx2_Vector128/BroadcastScalarToVector256.Int16.cs
index 8fe05cea3ddb..e40b57572d16 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Avx2_Vector128/BroadcastScalarToVector256.Int16.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx2_Vector128/BroadcastScalarToVector256.Int16.cs
@@ -133,9 +133,11 @@ private void ValidateResult(void* firstOp, void* result, [CallerMemberName] stri
 
         private void ValidateResult(Int16[] firstOp, Int16[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (firstOp[0] != result[0])
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -143,18 +145,20 @@ private void ValidateResult(Int16[] firstOp, Int16[] result, [CallerMemberName]
                 {
                     if ((firstOp[0] != result[i]))
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Avx2)}.{nameof(Avx2.BroadcastScalarToVector256)}<Int16>(Vector128<Int16>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"  firstOp: ({string.Join(", ", firstOp)})");
                 TestLibrary.TestFramework.LogInformation($"   result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx2_Vector128/BroadcastScalarToVector256.Int32.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx2_Vector128/BroadcastScalarToVector256.Int32.cs
index 941d39d499d3..056c5a7b52f9 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Avx2_Vector128/BroadcastScalarToVector256.Int32.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx2_Vector128/BroadcastScalarToVector256.Int32.cs
@@ -133,9 +133,11 @@ private void ValidateResult(void* firstOp, void* result, [CallerMemberName] stri
 
         private void ValidateResult(Int32[] firstOp, Int32[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (firstOp[0] != result[0])
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -143,18 +145,20 @@ private void ValidateResult(Int32[] firstOp, Int32[] result, [CallerMemberName]
                 {
                     if ((firstOp[0] != result[i]))
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Avx2)}.{nameof(Avx2.BroadcastScalarToVector256)}<Int32>(Vector128<Int32>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"  firstOp: ({string.Join(", ", firstOp)})");
                 TestLibrary.TestFramework.LogInformation($"   result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx2_Vector128/BroadcastScalarToVector256.Int64.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx2_Vector128/BroadcastScalarToVector256.Int64.cs
index 2f56c31eff72..b9d0cb176482 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Avx2_Vector128/BroadcastScalarToVector256.Int64.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx2_Vector128/BroadcastScalarToVector256.Int64.cs
@@ -133,9 +133,11 @@ private void ValidateResult(void* firstOp, void* result, [CallerMemberName] stri
 
         private void ValidateResult(Int64[] firstOp, Int64[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (firstOp[0] != result[0])
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -143,18 +145,20 @@ private void ValidateResult(Int64[] firstOp, Int64[] result, [CallerMemberName]
                 {
                     if ((firstOp[0] != result[i]))
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Avx2)}.{nameof(Avx2.BroadcastScalarToVector256)}<Int64>(Vector128<Int64>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"  firstOp: ({string.Join(", ", firstOp)})");
                 TestLibrary.TestFramework.LogInformation($"   result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx2_Vector128/BroadcastScalarToVector256.SByte.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx2_Vector128/BroadcastScalarToVector256.SByte.cs
index 8ea39c3f7901..0a5e099b0821 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Avx2_Vector128/BroadcastScalarToVector256.SByte.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx2_Vector128/BroadcastScalarToVector256.SByte.cs
@@ -133,9 +133,11 @@ private void ValidateResult(void* firstOp, void* result, [CallerMemberName] stri
 
         private void ValidateResult(SByte[] firstOp, SByte[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (firstOp[0] != result[0])
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -143,18 +145,20 @@ private void ValidateResult(SByte[] firstOp, SByte[] result, [CallerMemberName]
                 {
                     if ((firstOp[0] != result[i]))
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Avx2)}.{nameof(Avx2.BroadcastScalarToVector256)}<SByte>(Vector128<SByte>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"  firstOp: ({string.Join(", ", firstOp)})");
                 TestLibrary.TestFramework.LogInformation($"   result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx2_Vector128/BroadcastScalarToVector256.UInt16.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx2_Vector128/BroadcastScalarToVector256.UInt16.cs
index fc141dbab2ba..0448cb155dd8 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Avx2_Vector128/BroadcastScalarToVector256.UInt16.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx2_Vector128/BroadcastScalarToVector256.UInt16.cs
@@ -133,9 +133,11 @@ private void ValidateResult(void* firstOp, void* result, [CallerMemberName] stri
 
         private void ValidateResult(UInt16[] firstOp, UInt16[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (firstOp[0] != result[0])
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -143,18 +145,20 @@ private void ValidateResult(UInt16[] firstOp, UInt16[] result, [CallerMemberName
                 {
                     if ((firstOp[0] != result[i]))
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Avx2)}.{nameof(Avx2.BroadcastScalarToVector256)}<UInt16>(Vector128<UInt16>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"  firstOp: ({string.Join(", ", firstOp)})");
                 TestLibrary.TestFramework.LogInformation($"   result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx2_Vector128/BroadcastScalarToVector256.UInt32.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx2_Vector128/BroadcastScalarToVector256.UInt32.cs
index 58ddb1cc68df..c81392f366ca 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Avx2_Vector128/BroadcastScalarToVector256.UInt32.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx2_Vector128/BroadcastScalarToVector256.UInt32.cs
@@ -133,9 +133,11 @@ private void ValidateResult(void* firstOp, void* result, [CallerMemberName] stri
 
         private void ValidateResult(UInt32[] firstOp, UInt32[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (firstOp[0] != result[0])
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -143,18 +145,20 @@ private void ValidateResult(UInt32[] firstOp, UInt32[] result, [CallerMemberName
                 {
                     if ((firstOp[0] != result[i]))
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Avx2)}.{nameof(Avx2.BroadcastScalarToVector256)}<UInt32>(Vector128<UInt32>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"  firstOp: ({string.Join(", ", firstOp)})");
                 TestLibrary.TestFramework.LogInformation($"   result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx2_Vector128/BroadcastScalarToVector256.UInt64.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx2_Vector128/BroadcastScalarToVector256.UInt64.cs
index 837bc0c2937e..f36830f58a98 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Avx2_Vector128/BroadcastScalarToVector256.UInt64.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx2_Vector128/BroadcastScalarToVector256.UInt64.cs
@@ -133,9 +133,11 @@ private void ValidateResult(void* firstOp, void* result, [CallerMemberName] stri
 
         private void ValidateResult(UInt64[] firstOp, UInt64[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (firstOp[0] != result[0])
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -143,18 +145,20 @@ private void ValidateResult(UInt64[] firstOp, UInt64[] result, [CallerMemberName
                 {
                     if ((firstOp[0] != result[i]))
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Avx2)}.{nameof(Avx2.BroadcastScalarToVector256)}<UInt64>(Vector128<UInt64>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"  firstOp: ({string.Join(", ", firstOp)})");
                 TestLibrary.TestFramework.LogInformation($"   result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx2_Vector128/MaskLoad.Int32.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx2_Vector128/MaskLoad.Int32.cs
index ad07ffe8fcf6..c9263a5dd982 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Avx2_Vector128/MaskLoad.Int32.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx2_Vector128/MaskLoad.Int32.cs
@@ -331,7 +331,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -339,7 +339,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -371,9 +376,11 @@ private void ValidateResult(void* left, void* right, void* result, [CallerMember
 
         private void ValidateResult(Int32[] left, Int32[] right, Int32[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (result[0] != ((right[0] < 0) ? left[0] : 0))
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -381,19 +388,21 @@ private void ValidateResult(Int32[] left, Int32[] right, Int32[] result, [Caller
                 {
                     if (result[i] != ((right[i] < 0) ? left[i] : 0))
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Avx2)}.{nameof(Avx2.MaskLoad)}<Int32>(Int32*, Vector128<Int32>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx2_Vector128/MaskLoad.Int64.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx2_Vector128/MaskLoad.Int64.cs
index f81bbf7a3430..19ed5ca54f00 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Avx2_Vector128/MaskLoad.Int64.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx2_Vector128/MaskLoad.Int64.cs
@@ -331,7 +331,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -339,7 +339,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -371,9 +376,11 @@ private void ValidateResult(void* left, void* right, void* result, [CallerMember
 
         private void ValidateResult(Int64[] left, Int64[] right, Int64[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (result[0] != ((right[0] < 0) ? left[0] : 0))
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -381,19 +388,21 @@ private void ValidateResult(Int64[] left, Int64[] right, Int64[] result, [Caller
                 {
                     if (result[i] != ((right[i] < 0) ? left[i] : 0))
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Avx2)}.{nameof(Avx2.MaskLoad)}<Int64>(Int64*, Vector128<Int64>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx2_Vector128/MaskLoad.UInt32.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx2_Vector128/MaskLoad.UInt32.cs
index a518d526a764..42ec3efa5235 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Avx2_Vector128/MaskLoad.UInt32.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx2_Vector128/MaskLoad.UInt32.cs
@@ -331,7 +331,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -339,7 +339,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -371,9 +376,11 @@ private void ValidateResult(void* left, void* right, void* result, [CallerMember
 
         private void ValidateResult(UInt32[] left, UInt32[] right, UInt32[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (result[0] != (((right[0] & (1U << 31)) != 0) ? left[0] : 0))
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -381,19 +388,21 @@ private void ValidateResult(UInt32[] left, UInt32[] right, UInt32[] result, [Cal
                 {
                     if (result[i] != (((right[i] & (1U << 31)) != 0) ? left[i] : 0))
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Avx2)}.{nameof(Avx2.MaskLoad)}<UInt32>(UInt32*, Vector128<UInt32>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx2_Vector128/MaskLoad.UInt64.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx2_Vector128/MaskLoad.UInt64.cs
index ca4e1de8f412..606c844432d1 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Avx2_Vector128/MaskLoad.UInt64.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx2_Vector128/MaskLoad.UInt64.cs
@@ -331,7 +331,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -339,7 +339,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -371,9 +376,11 @@ private void ValidateResult(void* left, void* right, void* result, [CallerMember
 
         private void ValidateResult(UInt64[] left, UInt64[] right, UInt64[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (result[0] != (((right[0] & (1UL << 63)) != 0) ? left[0] : 0))
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -381,19 +388,21 @@ private void ValidateResult(UInt64[] left, UInt64[] right, UInt64[] result, [Cal
                 {
                     if (result[i] != (((right[i] & (1UL << 63)) != 0) ? left[i] : 0))
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Avx2)}.{nameof(Avx2.MaskLoad)}<UInt64>(UInt64*, Vector128<UInt64>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx2_Vector128/MaskStore.Int32.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx2_Vector128/MaskStore.Int32.cs
index 33d80c1316dd..e4815e22273a 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Avx2_Vector128/MaskStore.Int32.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx2_Vector128/MaskStore.Int32.cs
@@ -326,7 +326,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -334,7 +334,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -366,9 +371,11 @@ private void ValidateResult(void* left, void* right, void* result, [CallerMember
 
         private void ValidateResult(Int32[] left, Int32[] right, Int32[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (result[0] != ((left[0] < 0) ? right[0] : result[0]))
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -376,19 +383,21 @@ private void ValidateResult(Int32[] left, Int32[] right, Int32[] result, [Caller
                 {
                     if (result[i] != ((left[i] < 0) ? right[i] : result[i]))
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Avx2)}.{nameof(Avx2.MaskStore)}<Int32>(Vector128<Int32>, Vector128<Int32>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx2_Vector128/MaskStore.Int64.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx2_Vector128/MaskStore.Int64.cs
index d731f8bcc6d1..620767ad2e97 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Avx2_Vector128/MaskStore.Int64.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx2_Vector128/MaskStore.Int64.cs
@@ -326,7 +326,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -334,7 +334,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -366,9 +371,11 @@ private void ValidateResult(void* left, void* right, void* result, [CallerMember
 
         private void ValidateResult(Int64[] left, Int64[] right, Int64[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (result[0] != ((left[0] < 0) ? right[0] : result[0]))
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -376,19 +383,21 @@ private void ValidateResult(Int64[] left, Int64[] right, Int64[] result, [Caller
                 {
                     if (result[i] != ((left[i] < 0) ? right[i] : result[i]))
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Avx2)}.{nameof(Avx2.MaskStore)}<Int64>(Vector128<Int64>, Vector128<Int64>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx2_Vector128/MaskStore.UInt32.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx2_Vector128/MaskStore.UInt32.cs
index 6d30d3c5a993..0c263e082259 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Avx2_Vector128/MaskStore.UInt32.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx2_Vector128/MaskStore.UInt32.cs
@@ -326,7 +326,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -334,7 +334,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -366,9 +371,11 @@ private void ValidateResult(void* left, void* right, void* result, [CallerMember
 
         private void ValidateResult(UInt32[] left, UInt32[] right, UInt32[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (result[0] != (((left[0] & (1U << 31)) != 0) ? right[0] : result[0]))
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -376,19 +383,21 @@ private void ValidateResult(UInt32[] left, UInt32[] right, UInt32[] result, [Cal
                 {
                     if (result[i] != (((left[i] & (1U << 31)) != 0) ? right[i] : result[i]))
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Avx2)}.{nameof(Avx2.MaskStore)}<UInt32>(Vector128<UInt32>, Vector128<UInt32>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx2_Vector128/MaskStore.UInt64.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx2_Vector128/MaskStore.UInt64.cs
index c1932702049d..337247e1d2bc 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Avx2_Vector128/MaskStore.UInt64.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx2_Vector128/MaskStore.UInt64.cs
@@ -326,7 +326,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -334,7 +334,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -366,9 +371,11 @@ private void ValidateResult(void* left, void* right, void* result, [CallerMember
 
         private void ValidateResult(UInt64[] left, UInt64[] right, UInt64[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (result[0] != (((left[0] & (1UL << 63))  != 0) ? right[0] : result[0]))
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -376,19 +383,21 @@ private void ValidateResult(UInt64[] left, UInt64[] right, UInt64[] result, [Cal
                 {
                     if (result[i] != (((left[i] & (1UL << 63)) != 0) ? right[i] : result[i]))
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Avx2)}.{nameof(Avx2.MaskStore)}<UInt64>(Vector128<UInt64>, Vector128<UInt64>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx2_Vector128/ShiftRightArithmeticVariable.Int32.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx2_Vector128/ShiftRightArithmeticVariable.Int32.cs
index 21240b5b437a..5282b39dbe2b 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Avx2_Vector128/ShiftRightArithmeticVariable.Int32.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx2_Vector128/ShiftRightArithmeticVariable.Int32.cs
@@ -334,7 +334,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -342,7 +342,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -374,9 +379,11 @@ private void ValidateResult(void* left, void* right, void* result, [CallerMember
 
         private void ValidateResult(Int32[] left, UInt32[] right, Int32[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if ((int)(left[0] >> (int)right[0]) != result[0])
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -384,19 +391,21 @@ private void ValidateResult(Int32[] left, UInt32[] right, Int32[] result, [Calle
                 {
                     if ((int)(left[i] >> (int)right[i]) != result[i])
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Avx2)}.{nameof(Avx2.ShiftRightArithmeticVariable)}<Int32>(Vector128<Int32>, Vector128<UInt32>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx_Vector128/MaskLoad.Double.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx_Vector128/MaskLoad.Double.cs
index 1a8806c0289a..06946c46e80a 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Avx_Vector128/MaskLoad.Double.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx_Vector128/MaskLoad.Double.cs
@@ -331,7 +331,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -339,7 +339,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -371,9 +376,11 @@ private void ValidateResult(void* left, void* right, void* result, [CallerMember
 
         private void ValidateResult(Double[] left, Double[] right, Double[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (BitConverter.DoubleToInt64Bits(result[0]) != BitConverter.DoubleToInt64Bits((BitConverter.DoubleToInt64Bits(right[0]) < 0) ? left[0] : 0))
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -381,19 +388,21 @@ private void ValidateResult(Double[] left, Double[] right, Double[] result, [Cal
                 {
                     if (BitConverter.DoubleToInt64Bits(result[i]) != BitConverter.DoubleToInt64Bits((BitConverter.DoubleToInt64Bits(right[i]) < 0) ? left[i] : 0))
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Avx)}.{nameof(Avx.MaskLoad)}<Double>(Double*, Vector128<Double>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx_Vector128/MaskLoad.Single.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx_Vector128/MaskLoad.Single.cs
index e9249077464e..231b529cef3c 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Avx_Vector128/MaskLoad.Single.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx_Vector128/MaskLoad.Single.cs
@@ -331,7 +331,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -339,7 +339,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -371,9 +376,11 @@ private void ValidateResult(void* left, void* right, void* result, [CallerMember
 
         private void ValidateResult(Single[] left, Single[] right, Single[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (BitConverter.SingleToInt32Bits(result[0]) != BitConverter.SingleToInt32Bits((BitConverter.SingleToInt32Bits(right[0]) < 0) ? left[0] : 0))
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -381,19 +388,21 @@ private void ValidateResult(Single[] left, Single[] right, Single[] result, [Cal
                 {
                     if (BitConverter.SingleToInt32Bits(result[i]) != BitConverter.SingleToInt32Bits((BitConverter.SingleToInt32Bits(right[i]) < 0) ? left[i] : 0))
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Avx)}.{nameof(Avx.MaskLoad)}<Single>(Single*, Vector128<Single>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx_Vector128/MaskStore.Double.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx_Vector128/MaskStore.Double.cs
index 64a8757f3e6c..82b629e86231 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Avx_Vector128/MaskStore.Double.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx_Vector128/MaskStore.Double.cs
@@ -326,7 +326,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -334,7 +334,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -366,9 +371,11 @@ private void ValidateResult(void* left, void* right, void* result, [CallerMember
 
         private void ValidateResult(Double[] left, Double[] right, Double[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (BitConverter.DoubleToInt64Bits(result[0]) != BitConverter.DoubleToInt64Bits((BitConverter.DoubleToInt64Bits(left[0]) < 0) ? right[0] : BitConverter.DoubleToInt64Bits(result[0])))
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -376,19 +383,21 @@ private void ValidateResult(Double[] left, Double[] right, Double[] result, [Cal
                 {
                     if (BitConverter.DoubleToInt64Bits(result[i]) != BitConverter.DoubleToInt64Bits((BitConverter.DoubleToInt64Bits(left[i]) < 0) ? right[i] : BitConverter.DoubleToInt64Bits(result[i])))
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Avx)}.{nameof(Avx.MaskStore)}<Double>(Vector128<Double>, Vector128<Double>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx_Vector128/MaskStore.Single.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx_Vector128/MaskStore.Single.cs
index 9ac35daabf3c..8501dce2ab2e 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Avx_Vector128/MaskStore.Single.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx_Vector128/MaskStore.Single.cs
@@ -326,7 +326,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -334,7 +334,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -366,9 +371,11 @@ private void ValidateResult(void* left, void* right, void* result, [CallerMember
 
         private void ValidateResult(Single[] left, Single[] right, Single[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (BitConverter.SingleToInt32Bits(result[0]) != BitConverter.SingleToInt32Bits((BitConverter.SingleToInt32Bits(left[0]) < 0) ? right[0] : BitConverter.SingleToInt32Bits(result[0])))
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -376,19 +383,21 @@ private void ValidateResult(Single[] left, Single[] right, Single[] result, [Cal
                 {
                     if (BitConverter.SingleToInt32Bits(result[i]) != BitConverter.SingleToInt32Bits((BitConverter.SingleToInt32Bits(left[i]) < 0) ? right[i] : BitConverter.SingleToInt32Bits(result[i])))
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Avx)}.{nameof(Avx.MaskStore)}<Single>(Vector128<Single>, Vector128<Single>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Bmi1/AndNot.UInt32.cs b/tests/src/JIT/HardwareIntrinsics/X86/Bmi1/AndNot.UInt32.cs
index 4ee3afb045e9..6973b4c9c0e1 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Bmi1/AndNot.UInt32.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Bmi1/AndNot.UInt32.cs
@@ -204,7 +204,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -212,7 +212,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -229,6 +234,8 @@ private void ValidateResult(UInt32 left, UInt32 right, UInt32 result, [CallerMem
                 TestLibrary.TestFramework.LogInformation($"   right: {right}");
                 TestLibrary.TestFramework.LogInformation($"  result: {result}");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Bmi1/AndNot.UInt64.cs b/tests/src/JIT/HardwareIntrinsics/X86/Bmi1/AndNot.UInt64.cs
index 8855e1e6eb88..fe895d2753b4 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Bmi1/AndNot.UInt64.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Bmi1/AndNot.UInt64.cs
@@ -204,7 +204,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -212,7 +212,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -229,6 +234,8 @@ private void ValidateResult(UInt64 left, UInt64 right, UInt64 result, [CallerMem
                 TestLibrary.TestFramework.LogInformation($"   right: {right}");
                 TestLibrary.TestFramework.LogInformation($"  result: {result}");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Bmi1/ExtractLowestSetBit.UInt32.cs b/tests/src/JIT/HardwareIntrinsics/X86/Bmi1/ExtractLowestSetBit.UInt32.cs
index e253031708f0..09568ffef883 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Bmi1/ExtractLowestSetBit.UInt32.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Bmi1/ExtractLowestSetBit.UInt32.cs
@@ -191,7 +191,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -199,7 +199,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -215,6 +220,8 @@ private void ValidateResult(UInt32 data, UInt32 result, [CallerMemberName] strin
                 TestLibrary.TestFramework.LogInformation($"    data: {data}");
                 TestLibrary.TestFramework.LogInformation($"  result: {result}");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Bmi1/ExtractLowestSetBit.UInt64.cs b/tests/src/JIT/HardwareIntrinsics/X86/Bmi1/ExtractLowestSetBit.UInt64.cs
index 035440aa9a9c..47b4c250057b 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Bmi1/ExtractLowestSetBit.UInt64.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Bmi1/ExtractLowestSetBit.UInt64.cs
@@ -191,7 +191,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -199,7 +199,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -215,6 +220,8 @@ private void ValidateResult(UInt64 data, UInt64 result, [CallerMemberName] strin
                 TestLibrary.TestFramework.LogInformation($"    data: {data}");
                 TestLibrary.TestFramework.LogInformation($"  result: {result}");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Bmi1/GetMaskUpToLowestSetBit.UInt32.cs b/tests/src/JIT/HardwareIntrinsics/X86/Bmi1/GetMaskUpToLowestSetBit.UInt32.cs
index 3b1bb155cc36..6ab9348874f1 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Bmi1/GetMaskUpToLowestSetBit.UInt32.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Bmi1/GetMaskUpToLowestSetBit.UInt32.cs
@@ -191,7 +191,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -199,7 +199,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -215,6 +220,8 @@ private void ValidateResult(UInt32 data, UInt32 result, [CallerMemberName] strin
                 TestLibrary.TestFramework.LogInformation($"    data: {data}");
                 TestLibrary.TestFramework.LogInformation($"  result: {result}");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Bmi1/GetMaskUpToLowestSetBit.UInt64.cs b/tests/src/JIT/HardwareIntrinsics/X86/Bmi1/GetMaskUpToLowestSetBit.UInt64.cs
index b72308407bf8..6954c61e2ce3 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Bmi1/GetMaskUpToLowestSetBit.UInt64.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Bmi1/GetMaskUpToLowestSetBit.UInt64.cs
@@ -191,7 +191,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -199,7 +199,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -215,6 +220,8 @@ private void ValidateResult(UInt64 data, UInt64 result, [CallerMemberName] strin
                 TestLibrary.TestFramework.LogInformation($"    data: {data}");
                 TestLibrary.TestFramework.LogInformation($"  result: {result}");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Bmi1/ResetLowestSetBit.UInt32.cs b/tests/src/JIT/HardwareIntrinsics/X86/Bmi1/ResetLowestSetBit.UInt32.cs
index 293e62211c72..c4bd16628c51 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Bmi1/ResetLowestSetBit.UInt32.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Bmi1/ResetLowestSetBit.UInt32.cs
@@ -191,7 +191,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -199,7 +199,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -215,6 +220,8 @@ private void ValidateResult(UInt32 data, UInt32 result, [CallerMemberName] strin
                 TestLibrary.TestFramework.LogInformation($"    data: {data}");
                 TestLibrary.TestFramework.LogInformation($"  result: {result}");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Bmi1/ResetLowestSetBit.UInt64.cs b/tests/src/JIT/HardwareIntrinsics/X86/Bmi1/ResetLowestSetBit.UInt64.cs
index 11e7a7c89c50..45ed67dac6a8 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Bmi1/ResetLowestSetBit.UInt64.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Bmi1/ResetLowestSetBit.UInt64.cs
@@ -191,7 +191,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -199,7 +199,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -215,6 +220,8 @@ private void ValidateResult(UInt64 data, UInt64 result, [CallerMemberName] strin
                 TestLibrary.TestFramework.LogInformation($"    data: {data}");
                 TestLibrary.TestFramework.LogInformation($"  result: {result}");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Bmi1/TrailingZeroCount.UInt32.cs b/tests/src/JIT/HardwareIntrinsics/X86/Bmi1/TrailingZeroCount.UInt32.cs
index 16699cd92239..4de839806669 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Bmi1/TrailingZeroCount.UInt32.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Bmi1/TrailingZeroCount.UInt32.cs
@@ -191,7 +191,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -199,7 +199,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -215,6 +220,8 @@ private void ValidateResult(UInt32 data, UInt32 result, [CallerMemberName] strin
                 TestLibrary.TestFramework.LogInformation($"    data: {data}");
                 TestLibrary.TestFramework.LogInformation($"  result: {result}");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Bmi1/TrailingZeroCount.UInt64.cs b/tests/src/JIT/HardwareIntrinsics/X86/Bmi1/TrailingZeroCount.UInt64.cs
index 9eb1abf2b6e6..959174b7e7a2 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Bmi1/TrailingZeroCount.UInt64.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Bmi1/TrailingZeroCount.UInt64.cs
@@ -191,7 +191,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -199,7 +199,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -215,6 +220,8 @@ private void ValidateResult(UInt64 data, UInt64 result, [CallerMemberName] strin
                 TestLibrary.TestFramework.LogInformation($"    data: {data}");
                 TestLibrary.TestFramework.LogInformation($"  result: {result}");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Bmi2/ParallelBitDeposit.UInt32.cs b/tests/src/JIT/HardwareIntrinsics/X86/Bmi2/ParallelBitDeposit.UInt32.cs
index b3369e209a3b..c4b511b92544 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Bmi2/ParallelBitDeposit.UInt32.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Bmi2/ParallelBitDeposit.UInt32.cs
@@ -204,7 +204,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -212,7 +212,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -251,6 +256,8 @@ private void ValidateResult(UInt32 left, UInt32 right, UInt32 result, [CallerMem
                 TestLibrary.TestFramework.LogInformation($"   right: {right}");
                 TestLibrary.TestFramework.LogInformation($"  result: {result}");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Bmi2/ParallelBitDeposit.UInt64.cs b/tests/src/JIT/HardwareIntrinsics/X86/Bmi2/ParallelBitDeposit.UInt64.cs
index 144611c03b54..7c0ce245b113 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Bmi2/ParallelBitDeposit.UInt64.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Bmi2/ParallelBitDeposit.UInt64.cs
@@ -204,7 +204,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -212,7 +212,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -251,6 +256,8 @@ private void ValidateResult(UInt64 left, UInt64 right, UInt64 result, [CallerMem
                 TestLibrary.TestFramework.LogInformation($"   right: {right}");
                 TestLibrary.TestFramework.LogInformation($"  result: {result}");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Bmi2/ParallelBitExtract.UInt32.cs b/tests/src/JIT/HardwareIntrinsics/X86/Bmi2/ParallelBitExtract.UInt32.cs
index ea316466f764..d0de11aea143 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Bmi2/ParallelBitExtract.UInt32.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Bmi2/ParallelBitExtract.UInt32.cs
@@ -204,7 +204,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -212,7 +212,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -251,6 +256,8 @@ private void ValidateResult(UInt32 left, UInt32 right, UInt32 result, [CallerMem
                 TestLibrary.TestFramework.LogInformation($"   right: {right}");
                 TestLibrary.TestFramework.LogInformation($"  result: {result}");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Bmi2/ParallelBitExtract.UInt64.cs b/tests/src/JIT/HardwareIntrinsics/X86/Bmi2/ParallelBitExtract.UInt64.cs
index faff29100a47..ebbf215f9226 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Bmi2/ParallelBitExtract.UInt64.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Bmi2/ParallelBitExtract.UInt64.cs
@@ -204,7 +204,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -212,7 +212,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -251,6 +256,8 @@ private void ValidateResult(UInt64 left, UInt64 right, UInt64 result, [CallerMem
                 TestLibrary.TestFramework.LogInformation($"   right: {right}");
                 TestLibrary.TestFramework.LogInformation($"  result: {result}");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Fma_Vector128/MultiplyAdd.Double.cs b/tests/src/JIT/HardwareIntrinsics/X86/Fma_Vector128/MultiplyAdd.Double.cs
index 742b220e9c59..3f5cb2a5f134 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Fma_Vector128/MultiplyAdd.Double.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Fma_Vector128/MultiplyAdd.Double.cs
@@ -356,7 +356,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -364,7 +364,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -400,9 +405,11 @@ private void ValidateResult(void* firstOp, void* secondOp, void* thirdOp, void*
 
         private void ValidateResult(Double[] firstOp, Double[] secondOp, Double[] thirdOp, Double[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (BitConverter.DoubleToInt64Bits(Math.Round((firstOp[0] * secondOp[0]) + thirdOp[0], 9)) != BitConverter.DoubleToInt64Bits(Math.Round(result[0], 9)))
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -410,13 +417,13 @@ private void ValidateResult(Double[] firstOp, Double[] secondOp, Double[] thirdO
                 {
                     if (BitConverter.DoubleToInt64Bits(Math.Round((firstOp[i] * secondOp[i]) + thirdOp[i], 9)) != BitConverter.DoubleToInt64Bits(Math.Round(result[i], 9)))
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Fma)}.{nameof(Fma.MultiplyAdd)}<Double>(Vector128<Double>, Vector128<Double>, Vector128<Double>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"   firstOp: ({string.Join(", ", firstOp)})");
@@ -424,6 +431,8 @@ private void ValidateResult(Double[] firstOp, Double[] secondOp, Double[] thirdO
                 TestLibrary.TestFramework.LogInformation($"   thirdOp: ({string.Join(", ", thirdOp)})");
                 TestLibrary.TestFramework.LogInformation($"    result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Fma_Vector128/MultiplyAdd.Single.cs b/tests/src/JIT/HardwareIntrinsics/X86/Fma_Vector128/MultiplyAdd.Single.cs
index 470b2a205a1c..2d17488d14a5 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Fma_Vector128/MultiplyAdd.Single.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Fma_Vector128/MultiplyAdd.Single.cs
@@ -356,7 +356,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -364,7 +364,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -400,9 +405,11 @@ private void ValidateResult(void* firstOp, void* secondOp, void* thirdOp, void*
 
         private void ValidateResult(Single[] firstOp, Single[] secondOp, Single[] thirdOp, Single[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (BitConverter.SingleToInt32Bits(MathF.Round((firstOp[0] * secondOp[0]) + thirdOp[0], 3)) != BitConverter.SingleToInt32Bits(MathF.Round(result[0], 3)))
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -410,13 +417,13 @@ private void ValidateResult(Single[] firstOp, Single[] secondOp, Single[] thirdO
                 {
                     if (BitConverter.SingleToInt32Bits(MathF.Round((firstOp[i] * secondOp[i]) + thirdOp[i], 3)) != BitConverter.SingleToInt32Bits(MathF.Round(result[i], 3)))
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Fma)}.{nameof(Fma.MultiplyAdd)}<Single>(Vector128<Single>, Vector128<Single>, Vector128<Single>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"   firstOp: ({string.Join(", ", firstOp)})");
@@ -424,6 +431,8 @@ private void ValidateResult(Single[] firstOp, Single[] secondOp, Single[] thirdO
                 TestLibrary.TestFramework.LogInformation($"   thirdOp: ({string.Join(", ", thirdOp)})");
                 TestLibrary.TestFramework.LogInformation($"    result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Fma_Vector128/MultiplyAddNegated.Double.cs b/tests/src/JIT/HardwareIntrinsics/X86/Fma_Vector128/MultiplyAddNegated.Double.cs
index 2ed78b6708c9..d26e791133ee 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Fma_Vector128/MultiplyAddNegated.Double.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Fma_Vector128/MultiplyAddNegated.Double.cs
@@ -356,7 +356,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -364,7 +364,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -400,9 +405,11 @@ private void ValidateResult(void* firstOp, void* secondOp, void* thirdOp, void*
 
         private void ValidateResult(Double[] firstOp, Double[] secondOp, Double[] thirdOp, Double[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (BitConverter.DoubleToInt64Bits(Math.Round(-(firstOp[0] * secondOp[0]) + thirdOp[0], 9)) != BitConverter.DoubleToInt64Bits(Math.Round(result[0], 9)))
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -410,13 +417,13 @@ private void ValidateResult(Double[] firstOp, Double[] secondOp, Double[] thirdO
                 {
                     if (BitConverter.DoubleToInt64Bits(Math.Round(-(firstOp[i] * secondOp[i]) + thirdOp[i], 9)) != BitConverter.DoubleToInt64Bits(Math.Round(result[i], 9)))
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Fma)}.{nameof(Fma.MultiplyAddNegated)}<Double>(Vector128<Double>, Vector128<Double>, Vector128<Double>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"   firstOp: ({string.Join(", ", firstOp)})");
@@ -424,6 +431,8 @@ private void ValidateResult(Double[] firstOp, Double[] secondOp, Double[] thirdO
                 TestLibrary.TestFramework.LogInformation($"   thirdOp: ({string.Join(", ", thirdOp)})");
                 TestLibrary.TestFramework.LogInformation($"    result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Fma_Vector128/MultiplyAddNegated.Single.cs b/tests/src/JIT/HardwareIntrinsics/X86/Fma_Vector128/MultiplyAddNegated.Single.cs
index ee5984cad9dd..f0a7a7664f6e 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Fma_Vector128/MultiplyAddNegated.Single.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Fma_Vector128/MultiplyAddNegated.Single.cs
@@ -356,7 +356,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -364,7 +364,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -400,9 +405,11 @@ private void ValidateResult(void* firstOp, void* secondOp, void* thirdOp, void*
 
         private void ValidateResult(Single[] firstOp, Single[] secondOp, Single[] thirdOp, Single[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (BitConverter.SingleToInt32Bits(MathF.Round(-(firstOp[0] * secondOp[0]) + thirdOp[0], 3)) != BitConverter.SingleToInt32Bits(MathF.Round(result[0], 3)))
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -410,13 +417,13 @@ private void ValidateResult(Single[] firstOp, Single[] secondOp, Single[] thirdO
                 {
                     if (BitConverter.SingleToInt32Bits(MathF.Round(-(firstOp[i] * secondOp[i]) + thirdOp[i], 3)) != BitConverter.SingleToInt32Bits(MathF.Round(result[i], 3)))
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Fma)}.{nameof(Fma.MultiplyAddNegated)}<Single>(Vector128<Single>, Vector128<Single>, Vector128<Single>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"   firstOp: ({string.Join(", ", firstOp)})");
@@ -424,6 +431,8 @@ private void ValidateResult(Single[] firstOp, Single[] secondOp, Single[] thirdO
                 TestLibrary.TestFramework.LogInformation($"   thirdOp: ({string.Join(", ", thirdOp)})");
                 TestLibrary.TestFramework.LogInformation($"    result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Fma_Vector128/MultiplyAddNegatedScalar.Double.cs b/tests/src/JIT/HardwareIntrinsics/X86/Fma_Vector128/MultiplyAddNegatedScalar.Double.cs
index 5e9bc3b2ba78..455f1e781495 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Fma_Vector128/MultiplyAddNegatedScalar.Double.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Fma_Vector128/MultiplyAddNegatedScalar.Double.cs
@@ -356,7 +356,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -364,7 +364,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -400,9 +405,11 @@ private void ValidateResult(void* firstOp, void* secondOp, void* thirdOp, void*
 
         private void ValidateResult(Double[] firstOp, Double[] secondOp, Double[] thirdOp, Double[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (BitConverter.DoubleToInt64Bits(Math.Round(-(firstOp[0] * secondOp[0]) + thirdOp[0], 9)) != BitConverter.DoubleToInt64Bits(Math.Round(result[0], 9)))
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -410,13 +417,13 @@ private void ValidateResult(Double[] firstOp, Double[] secondOp, Double[] thirdO
                 {
                     if (BitConverter.DoubleToInt64Bits(firstOp[i]) != BitConverter.DoubleToInt64Bits(result[i]))
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Fma)}.{nameof(Fma.MultiplyAddNegatedScalar)}<Double>(Vector128<Double>, Vector128<Double>, Vector128<Double>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"   firstOp: ({string.Join(", ", firstOp)})");
@@ -424,6 +431,8 @@ private void ValidateResult(Double[] firstOp, Double[] secondOp, Double[] thirdO
                 TestLibrary.TestFramework.LogInformation($"   thirdOp: ({string.Join(", ", thirdOp)})");
                 TestLibrary.TestFramework.LogInformation($"    result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Fma_Vector128/MultiplyAddNegatedScalar.Single.cs b/tests/src/JIT/HardwareIntrinsics/X86/Fma_Vector128/MultiplyAddNegatedScalar.Single.cs
index 6a3f8fa187a3..19515c0d02b1 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Fma_Vector128/MultiplyAddNegatedScalar.Single.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Fma_Vector128/MultiplyAddNegatedScalar.Single.cs
@@ -356,7 +356,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -364,7 +364,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -400,9 +405,11 @@ private void ValidateResult(void* firstOp, void* secondOp, void* thirdOp, void*
 
         private void ValidateResult(Single[] firstOp, Single[] secondOp, Single[] thirdOp, Single[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (BitConverter.SingleToInt32Bits(MathF.Round(-(firstOp[0] * secondOp[0]) + thirdOp[0], 3)) != BitConverter.SingleToInt32Bits(MathF.Round(result[0], 3)))
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -410,13 +417,13 @@ private void ValidateResult(Single[] firstOp, Single[] secondOp, Single[] thirdO
                 {
                     if (BitConverter.SingleToInt32Bits(firstOp[i]) != BitConverter.SingleToInt32Bits(result[i]))
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Fma)}.{nameof(Fma.MultiplyAddNegatedScalar)}<Single>(Vector128<Single>, Vector128<Single>, Vector128<Single>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"   firstOp: ({string.Join(", ", firstOp)})");
@@ -424,6 +431,8 @@ private void ValidateResult(Single[] firstOp, Single[] secondOp, Single[] thirdO
                 TestLibrary.TestFramework.LogInformation($"   thirdOp: ({string.Join(", ", thirdOp)})");
                 TestLibrary.TestFramework.LogInformation($"    result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Fma_Vector128/MultiplyAddScalar.Double.cs b/tests/src/JIT/HardwareIntrinsics/X86/Fma_Vector128/MultiplyAddScalar.Double.cs
index 9b069dd84988..cf9992547680 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Fma_Vector128/MultiplyAddScalar.Double.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Fma_Vector128/MultiplyAddScalar.Double.cs
@@ -356,7 +356,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -364,7 +364,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -400,9 +405,11 @@ private void ValidateResult(void* firstOp, void* secondOp, void* thirdOp, void*
 
         private void ValidateResult(Double[] firstOp, Double[] secondOp, Double[] thirdOp, Double[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (BitConverter.DoubleToInt64Bits(Math.Round((firstOp[0] * secondOp[0]) + thirdOp[0], 9)) != BitConverter.DoubleToInt64Bits(Math.Round(result[0], 9)))
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -410,13 +417,13 @@ private void ValidateResult(Double[] firstOp, Double[] secondOp, Double[] thirdO
                 {
                     if (BitConverter.DoubleToInt64Bits(firstOp[i]) != BitConverter.DoubleToInt64Bits(result[i]))
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Fma)}.{nameof(Fma.MultiplyAddScalar)}<Double>(Vector128<Double>, Vector128<Double>, Vector128<Double>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"   firstOp: ({string.Join(", ", firstOp)})");
@@ -424,6 +431,8 @@ private void ValidateResult(Double[] firstOp, Double[] secondOp, Double[] thirdO
                 TestLibrary.TestFramework.LogInformation($"   thirdOp: ({string.Join(", ", thirdOp)})");
                 TestLibrary.TestFramework.LogInformation($"    result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Fma_Vector128/MultiplyAddScalar.Single.cs b/tests/src/JIT/HardwareIntrinsics/X86/Fma_Vector128/MultiplyAddScalar.Single.cs
index 5b04a7bf74cc..aa456e9be3f8 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Fma_Vector128/MultiplyAddScalar.Single.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Fma_Vector128/MultiplyAddScalar.Single.cs
@@ -356,7 +356,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -364,7 +364,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -400,9 +405,11 @@ private void ValidateResult(void* firstOp, void* secondOp, void* thirdOp, void*
 
         private void ValidateResult(Single[] firstOp, Single[] secondOp, Single[] thirdOp, Single[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (BitConverter.SingleToInt32Bits(MathF.Round((firstOp[0] * secondOp[0]) + thirdOp[0], 3)) != BitConverter.SingleToInt32Bits(MathF.Round(result[0], 3)))
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -410,13 +417,13 @@ private void ValidateResult(Single[] firstOp, Single[] secondOp, Single[] thirdO
                 {
                     if (BitConverter.SingleToInt32Bits(firstOp[i]) != BitConverter.SingleToInt32Bits(result[i]))
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Fma)}.{nameof(Fma.MultiplyAddScalar)}<Single>(Vector128<Single>, Vector128<Single>, Vector128<Single>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"   firstOp: ({string.Join(", ", firstOp)})");
@@ -424,6 +431,8 @@ private void ValidateResult(Single[] firstOp, Single[] secondOp, Single[] thirdO
                 TestLibrary.TestFramework.LogInformation($"   thirdOp: ({string.Join(", ", thirdOp)})");
                 TestLibrary.TestFramework.LogInformation($"    result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Fma_Vector128/MultiplyAddSubtract.Double.cs b/tests/src/JIT/HardwareIntrinsics/X86/Fma_Vector128/MultiplyAddSubtract.Double.cs
index 1ebdb8d2a63d..33355711983a 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Fma_Vector128/MultiplyAddSubtract.Double.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Fma_Vector128/MultiplyAddSubtract.Double.cs
@@ -356,7 +356,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -364,7 +364,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -400,22 +405,24 @@ private void ValidateResult(void* firstOp, void* secondOp, void* thirdOp, void*
 
         private void ValidateResult(Double[] firstOp, Double[] secondOp, Double[] thirdOp, Double[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             for (var i = 0; i < RetElementCount; i += 2)
             {
                 if (BitConverter.DoubleToInt64Bits(Math.Round((firstOp[i] * secondOp[i]) - thirdOp[i], 9)) != BitConverter.DoubleToInt64Bits(Math.Round(result[i], 9)))
                 {
-                    Succeeded = false;
+                    succeeded = false;
                     break;
                 }
 
                 if (BitConverter.DoubleToInt64Bits(Math.Round((firstOp[i + 1] * secondOp[i + 1]) + thirdOp[i + 1], 9)) != BitConverter.DoubleToInt64Bits(Math.Round(result[i + 1], 9)))
                 {
-                    Succeeded = false;
+                    succeeded = false;
                     break;
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Fma)}.{nameof(Fma.MultiplyAddSubtract)}<Double>(Vector128<Double>, Vector128<Double>, Vector128<Double>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"   firstOp: ({string.Join(", ", firstOp)})");
@@ -423,6 +430,8 @@ private void ValidateResult(Double[] firstOp, Double[] secondOp, Double[] thirdO
                 TestLibrary.TestFramework.LogInformation($"   thirdOp: ({string.Join(", ", thirdOp)})");
                 TestLibrary.TestFramework.LogInformation($"    result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Fma_Vector128/MultiplyAddSubtract.Single.cs b/tests/src/JIT/HardwareIntrinsics/X86/Fma_Vector128/MultiplyAddSubtract.Single.cs
index bafd48bbd6e6..43f7fe879ffe 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Fma_Vector128/MultiplyAddSubtract.Single.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Fma_Vector128/MultiplyAddSubtract.Single.cs
@@ -356,7 +356,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -364,7 +364,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -400,22 +405,24 @@ private void ValidateResult(void* firstOp, void* secondOp, void* thirdOp, void*
 
         private void ValidateResult(Single[] firstOp, Single[] secondOp, Single[] thirdOp, Single[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             for (var i = 0; i < RetElementCount; i += 2)
             {
                 if (BitConverter.SingleToInt32Bits(MathF.Round((firstOp[i] * secondOp[i]) - thirdOp[i], 3)) != BitConverter.SingleToInt32Bits(MathF.Round(result[i], 3)))
                 {
-                    Succeeded = false;
+                    succeeded = false;
                     break;
                 }
 
                 if (BitConverter.SingleToInt32Bits(MathF.Round((firstOp[i + 1] * secondOp[i + 1]) + thirdOp[i + 1], 3)) != BitConverter.SingleToInt32Bits(MathF.Round(result[i + 1], 3)))
                 {
-                    Succeeded = false;
+                    succeeded = false;
                     break;
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Fma)}.{nameof(Fma.MultiplyAddSubtract)}<Single>(Vector128<Single>, Vector128<Single>, Vector128<Single>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"   firstOp: ({string.Join(", ", firstOp)})");
@@ -423,6 +430,8 @@ private void ValidateResult(Single[] firstOp, Single[] secondOp, Single[] thirdO
                 TestLibrary.TestFramework.LogInformation($"   thirdOp: ({string.Join(", ", thirdOp)})");
                 TestLibrary.TestFramework.LogInformation($"    result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Fma_Vector128/MultiplySubtract.Double.cs b/tests/src/JIT/HardwareIntrinsics/X86/Fma_Vector128/MultiplySubtract.Double.cs
index 49b8b3febebf..b406d3d226cd 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Fma_Vector128/MultiplySubtract.Double.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Fma_Vector128/MultiplySubtract.Double.cs
@@ -356,7 +356,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -364,7 +364,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -400,9 +405,11 @@ private void ValidateResult(void* firstOp, void* secondOp, void* thirdOp, void*
 
         private void ValidateResult(Double[] firstOp, Double[] secondOp, Double[] thirdOp, Double[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (BitConverter.DoubleToInt64Bits(Math.Round((firstOp[0] * secondOp[0]) - thirdOp[0], 9)) != BitConverter.DoubleToInt64Bits(Math.Round(result[0], 9)))
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -410,13 +417,13 @@ private void ValidateResult(Double[] firstOp, Double[] secondOp, Double[] thirdO
                 {
                     if (BitConverter.DoubleToInt64Bits(Math.Round((firstOp[i] * secondOp[i]) - thirdOp[i], 9)) != BitConverter.DoubleToInt64Bits(Math.Round(result[i], 9)))
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Fma)}.{nameof(Fma.MultiplySubtract)}<Double>(Vector128<Double>, Vector128<Double>, Vector128<Double>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"   firstOp: ({string.Join(", ", firstOp)})");
@@ -424,6 +431,8 @@ private void ValidateResult(Double[] firstOp, Double[] secondOp, Double[] thirdO
                 TestLibrary.TestFramework.LogInformation($"   thirdOp: ({string.Join(", ", thirdOp)})");
                 TestLibrary.TestFramework.LogInformation($"    result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Fma_Vector128/MultiplySubtract.Single.cs b/tests/src/JIT/HardwareIntrinsics/X86/Fma_Vector128/MultiplySubtract.Single.cs
index c955d90c251e..a03084c3acf2 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Fma_Vector128/MultiplySubtract.Single.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Fma_Vector128/MultiplySubtract.Single.cs
@@ -356,7 +356,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -364,7 +364,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -400,9 +405,11 @@ private void ValidateResult(void* firstOp, void* secondOp, void* thirdOp, void*
 
         private void ValidateResult(Single[] firstOp, Single[] secondOp, Single[] thirdOp, Single[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (BitConverter.SingleToInt32Bits(MathF.Round((firstOp[0] * secondOp[0]) - thirdOp[0], 3)) != BitConverter.SingleToInt32Bits(MathF.Round(result[0], 3)))
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -410,13 +417,13 @@ private void ValidateResult(Single[] firstOp, Single[] secondOp, Single[] thirdO
                 {
                     if (BitConverter.SingleToInt32Bits(MathF.Round((firstOp[i] * secondOp[i]) - thirdOp[i], 3)) != BitConverter.SingleToInt32Bits(MathF.Round(result[i], 3)))
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Fma)}.{nameof(Fma.MultiplySubtract)}<Single>(Vector128<Single>, Vector128<Single>, Vector128<Single>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"   firstOp: ({string.Join(", ", firstOp)})");
@@ -424,6 +431,8 @@ private void ValidateResult(Single[] firstOp, Single[] secondOp, Single[] thirdO
                 TestLibrary.TestFramework.LogInformation($"   thirdOp: ({string.Join(", ", thirdOp)})");
                 TestLibrary.TestFramework.LogInformation($"    result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Fma_Vector128/MultiplySubtractAdd.Double.cs b/tests/src/JIT/HardwareIntrinsics/X86/Fma_Vector128/MultiplySubtractAdd.Double.cs
index 5c30cd355ab7..10fe6ae9dd54 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Fma_Vector128/MultiplySubtractAdd.Double.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Fma_Vector128/MultiplySubtractAdd.Double.cs
@@ -356,7 +356,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -364,7 +364,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -400,22 +405,24 @@ private void ValidateResult(void* firstOp, void* secondOp, void* thirdOp, void*
 
         private void ValidateResult(Double[] firstOp, Double[] secondOp, Double[] thirdOp, Double[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             for (var i = 0; i < RetElementCount; i += 2)
             {
                 if (BitConverter.DoubleToInt64Bits(Math.Round((firstOp[i] * secondOp[i]) + thirdOp[i], 9)) != BitConverter.DoubleToInt64Bits(Math.Round(result[i], 9)))
                 {
-                    Succeeded = false;
+                    succeeded = false;
                     break;
                 }
 
                 if (BitConverter.DoubleToInt64Bits(Math.Round((firstOp[i + 1] * secondOp[i + 1]) - thirdOp[i + 1], 9)) != BitConverter.DoubleToInt64Bits(Math.Round(result[i + 1], 9)))
                 {
-                    Succeeded = false;
+                    succeeded = false;
                     break;
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Fma)}.{nameof(Fma.MultiplySubtractAdd)}<Double>(Vector128<Double>, Vector128<Double>, Vector128<Double>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"   firstOp: ({string.Join(", ", firstOp)})");
@@ -423,6 +430,8 @@ private void ValidateResult(Double[] firstOp, Double[] secondOp, Double[] thirdO
                 TestLibrary.TestFramework.LogInformation($"   thirdOp: ({string.Join(", ", thirdOp)})");
                 TestLibrary.TestFramework.LogInformation($"    result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Fma_Vector128/MultiplySubtractAdd.Single.cs b/tests/src/JIT/HardwareIntrinsics/X86/Fma_Vector128/MultiplySubtractAdd.Single.cs
index f0f491929970..2c0e72927987 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Fma_Vector128/MultiplySubtractAdd.Single.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Fma_Vector128/MultiplySubtractAdd.Single.cs
@@ -356,7 +356,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -364,7 +364,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -400,22 +405,24 @@ private void ValidateResult(void* firstOp, void* secondOp, void* thirdOp, void*
 
         private void ValidateResult(Single[] firstOp, Single[] secondOp, Single[] thirdOp, Single[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             for (var i = 0; i < RetElementCount; i += 2)
             {
                 if (BitConverter.SingleToInt32Bits(MathF.Round((firstOp[i] * secondOp[i]) + thirdOp[i], 3)) != BitConverter.SingleToInt32Bits(MathF.Round(result[i], 3)))
                 {
-                    Succeeded = false;
+                    succeeded = false;
                     break;
                 }
 
                 if (BitConverter.SingleToInt32Bits(MathF.Round((firstOp[i + 1] * secondOp[i + 1]) - thirdOp[i + 1], 3)) != BitConverter.SingleToInt32Bits(MathF.Round(result[i + 1], 3)))
                 {
-                    Succeeded = false;
+                    succeeded = false;
                     break;
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Fma)}.{nameof(Fma.MultiplySubtractAdd)}<Single>(Vector128<Single>, Vector128<Single>, Vector128<Single>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"   firstOp: ({string.Join(", ", firstOp)})");
@@ -423,6 +430,8 @@ private void ValidateResult(Single[] firstOp, Single[] secondOp, Single[] thirdO
                 TestLibrary.TestFramework.LogInformation($"   thirdOp: ({string.Join(", ", thirdOp)})");
                 TestLibrary.TestFramework.LogInformation($"    result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Fma_Vector128/MultiplySubtractNegated.Double.cs b/tests/src/JIT/HardwareIntrinsics/X86/Fma_Vector128/MultiplySubtractNegated.Double.cs
index a5399c683477..f0f9b0721ee8 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Fma_Vector128/MultiplySubtractNegated.Double.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Fma_Vector128/MultiplySubtractNegated.Double.cs
@@ -356,7 +356,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -364,7 +364,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -400,9 +405,11 @@ private void ValidateResult(void* firstOp, void* secondOp, void* thirdOp, void*
 
         private void ValidateResult(Double[] firstOp, Double[] secondOp, Double[] thirdOp, Double[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (BitConverter.DoubleToInt64Bits(Math.Round(-(firstOp[0] * secondOp[0]) - thirdOp[0], 9)) != BitConverter.DoubleToInt64Bits(Math.Round(result[0], 9)))
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -410,13 +417,13 @@ private void ValidateResult(Double[] firstOp, Double[] secondOp, Double[] thirdO
                 {
                     if (BitConverter.DoubleToInt64Bits(Math.Round(-(firstOp[i] * secondOp[i]) - thirdOp[i], 9)) != BitConverter.DoubleToInt64Bits(Math.Round(result[i], 9)))
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Fma)}.{nameof(Fma.MultiplySubtractNegated)}<Double>(Vector128<Double>, Vector128<Double>, Vector128<Double>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"   firstOp: ({string.Join(", ", firstOp)})");
@@ -424,6 +431,8 @@ private void ValidateResult(Double[] firstOp, Double[] secondOp, Double[] thirdO
                 TestLibrary.TestFramework.LogInformation($"   thirdOp: ({string.Join(", ", thirdOp)})");
                 TestLibrary.TestFramework.LogInformation($"    result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Fma_Vector128/MultiplySubtractNegated.Single.cs b/tests/src/JIT/HardwareIntrinsics/X86/Fma_Vector128/MultiplySubtractNegated.Single.cs
index 55e535a80f10..736751d754be 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Fma_Vector128/MultiplySubtractNegated.Single.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Fma_Vector128/MultiplySubtractNegated.Single.cs
@@ -356,7 +356,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -364,7 +364,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -400,9 +405,11 @@ private void ValidateResult(void* firstOp, void* secondOp, void* thirdOp, void*
 
         private void ValidateResult(Single[] firstOp, Single[] secondOp, Single[] thirdOp, Single[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (BitConverter.SingleToInt32Bits(MathF.Round(-(firstOp[0] * secondOp[0]) - thirdOp[0], 3)) != BitConverter.SingleToInt32Bits(MathF.Round(result[0], 3)))
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -410,13 +417,13 @@ private void ValidateResult(Single[] firstOp, Single[] secondOp, Single[] thirdO
                 {
                     if (BitConverter.SingleToInt32Bits(MathF.Round(-(firstOp[i] * secondOp[i]) - thirdOp[i], 3)) != BitConverter.SingleToInt32Bits(MathF.Round(result[i], 3)))
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Fma)}.{nameof(Fma.MultiplySubtractNegated)}<Single>(Vector128<Single>, Vector128<Single>, Vector128<Single>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"   firstOp: ({string.Join(", ", firstOp)})");
@@ -424,6 +431,8 @@ private void ValidateResult(Single[] firstOp, Single[] secondOp, Single[] thirdO
                 TestLibrary.TestFramework.LogInformation($"   thirdOp: ({string.Join(", ", thirdOp)})");
                 TestLibrary.TestFramework.LogInformation($"    result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Fma_Vector128/MultiplySubtractNegatedScalar.Double.cs b/tests/src/JIT/HardwareIntrinsics/X86/Fma_Vector128/MultiplySubtractNegatedScalar.Double.cs
index d9b7868ce5e2..2c7026e725e5 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Fma_Vector128/MultiplySubtractNegatedScalar.Double.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Fma_Vector128/MultiplySubtractNegatedScalar.Double.cs
@@ -356,7 +356,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -364,7 +364,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -400,9 +405,11 @@ private void ValidateResult(void* firstOp, void* secondOp, void* thirdOp, void*
 
         private void ValidateResult(Double[] firstOp, Double[] secondOp, Double[] thirdOp, Double[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (BitConverter.DoubleToInt64Bits(Math.Round(-(firstOp[0] * secondOp[0]) - thirdOp[0], 9)) != BitConverter.DoubleToInt64Bits(Math.Round(result[0], 9)))
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -410,13 +417,13 @@ private void ValidateResult(Double[] firstOp, Double[] secondOp, Double[] thirdO
                 {
                     if (BitConverter.DoubleToInt64Bits(firstOp[i]) != BitConverter.DoubleToInt64Bits(result[i]))
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Fma)}.{nameof(Fma.MultiplySubtractNegatedScalar)}<Double>(Vector128<Double>, Vector128<Double>, Vector128<Double>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"   firstOp: ({string.Join(", ", firstOp)})");
@@ -424,6 +431,8 @@ private void ValidateResult(Double[] firstOp, Double[] secondOp, Double[] thirdO
                 TestLibrary.TestFramework.LogInformation($"   thirdOp: ({string.Join(", ", thirdOp)})");
                 TestLibrary.TestFramework.LogInformation($"    result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Fma_Vector128/MultiplySubtractNegatedScalar.Single.cs b/tests/src/JIT/HardwareIntrinsics/X86/Fma_Vector128/MultiplySubtractNegatedScalar.Single.cs
index 3a3cd27dcfed..6a22de725541 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Fma_Vector128/MultiplySubtractNegatedScalar.Single.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Fma_Vector128/MultiplySubtractNegatedScalar.Single.cs
@@ -356,7 +356,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -364,7 +364,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -400,9 +405,11 @@ private void ValidateResult(void* firstOp, void* secondOp, void* thirdOp, void*
 
         private void ValidateResult(Single[] firstOp, Single[] secondOp, Single[] thirdOp, Single[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (BitConverter.SingleToInt32Bits(MathF.Round(-(firstOp[0] * secondOp[0]) - thirdOp[0], 3)) != BitConverter.SingleToInt32Bits(MathF.Round(result[0], 3)))
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -410,13 +417,13 @@ private void ValidateResult(Single[] firstOp, Single[] secondOp, Single[] thirdO
                 {
                     if (BitConverter.SingleToInt32Bits(firstOp[i]) != BitConverter.SingleToInt32Bits(result[i]))
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Fma)}.{nameof(Fma.MultiplySubtractNegatedScalar)}<Single>(Vector128<Single>, Vector128<Single>, Vector128<Single>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"   firstOp: ({string.Join(", ", firstOp)})");
@@ -424,6 +431,8 @@ private void ValidateResult(Single[] firstOp, Single[] secondOp, Single[] thirdO
                 TestLibrary.TestFramework.LogInformation($"   thirdOp: ({string.Join(", ", thirdOp)})");
                 TestLibrary.TestFramework.LogInformation($"    result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Fma_Vector128/MultiplySubtractScalar.Double.cs b/tests/src/JIT/HardwareIntrinsics/X86/Fma_Vector128/MultiplySubtractScalar.Double.cs
index d8f961023e26..68f1e77b6d10 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Fma_Vector128/MultiplySubtractScalar.Double.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Fma_Vector128/MultiplySubtractScalar.Double.cs
@@ -356,7 +356,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -364,7 +364,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -400,9 +405,11 @@ private void ValidateResult(void* firstOp, void* secondOp, void* thirdOp, void*
 
         private void ValidateResult(Double[] firstOp, Double[] secondOp, Double[] thirdOp, Double[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (BitConverter.DoubleToInt64Bits(Math.Round((firstOp[0] * secondOp[0]) - thirdOp[0], 9)) != BitConverter.DoubleToInt64Bits(Math.Round(result[0], 9)))
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -410,13 +417,13 @@ private void ValidateResult(Double[] firstOp, Double[] secondOp, Double[] thirdO
                 {
                     if (BitConverter.DoubleToInt64Bits(firstOp[i]) != BitConverter.DoubleToInt64Bits(result[i]))
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Fma)}.{nameof(Fma.MultiplySubtractScalar)}<Double>(Vector128<Double>, Vector128<Double>, Vector128<Double>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"   firstOp: ({string.Join(", ", firstOp)})");
@@ -424,6 +431,8 @@ private void ValidateResult(Double[] firstOp, Double[] secondOp, Double[] thirdO
                 TestLibrary.TestFramework.LogInformation($"   thirdOp: ({string.Join(", ", thirdOp)})");
                 TestLibrary.TestFramework.LogInformation($"    result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Fma_Vector128/MultiplySubtractScalar.Single.cs b/tests/src/JIT/HardwareIntrinsics/X86/Fma_Vector128/MultiplySubtractScalar.Single.cs
index cdc8b8a8be92..85e93468d90c 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Fma_Vector128/MultiplySubtractScalar.Single.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Fma_Vector128/MultiplySubtractScalar.Single.cs
@@ -356,7 +356,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -364,7 +364,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -400,9 +405,11 @@ private void ValidateResult(void* firstOp, void* secondOp, void* thirdOp, void*
 
         private void ValidateResult(Single[] firstOp, Single[] secondOp, Single[] thirdOp, Single[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (BitConverter.SingleToInt32Bits(MathF.Round((firstOp[0] * secondOp[0]) - thirdOp[0], 3)) != BitConverter.SingleToInt32Bits(MathF.Round(result[0], 3)))
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -410,13 +417,13 @@ private void ValidateResult(Single[] firstOp, Single[] secondOp, Single[] thirdO
                 {
                     if (BitConverter.SingleToInt32Bits(firstOp[i]) != BitConverter.SingleToInt32Bits(result[i]))
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Fma)}.{nameof(Fma.MultiplySubtractScalar)}<Single>(Vector128<Single>, Vector128<Single>, Vector128<Single>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"   firstOp: ({string.Join(", ", firstOp)})");
@@ -424,6 +431,8 @@ private void ValidateResult(Single[] firstOp, Single[] secondOp, Single[] thirdO
                 TestLibrary.TestFramework.LogInformation($"   thirdOp: ({string.Join(", ", thirdOp)})");
                 TestLibrary.TestFramework.LogInformation($"    result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Fma_Vector256/MultiplyAdd.Double.cs b/tests/src/JIT/HardwareIntrinsics/X86/Fma_Vector256/MultiplyAdd.Double.cs
index ef5c7388d4f8..dbad50d75e71 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Fma_Vector256/MultiplyAdd.Double.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Fma_Vector256/MultiplyAdd.Double.cs
@@ -356,7 +356,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -364,7 +364,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -400,9 +405,11 @@ private void ValidateResult(void* firstOp, void* secondOp, void* thirdOp, void*
 
         private void ValidateResult(Double[] firstOp, Double[] secondOp, Double[] thirdOp, Double[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (BitConverter.DoubleToInt64Bits(Math.Round((firstOp[0] * secondOp[0]) + thirdOp[0], 9)) != BitConverter.DoubleToInt64Bits(Math.Round(result[0], 9)))
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -410,13 +417,13 @@ private void ValidateResult(Double[] firstOp, Double[] secondOp, Double[] thirdO
                 {
                     if (BitConverter.DoubleToInt64Bits(Math.Round((firstOp[i] * secondOp[i]) + thirdOp[i], 9)) != BitConverter.DoubleToInt64Bits(Math.Round(result[i], 9)))
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Fma)}.{nameof(Fma.MultiplyAdd)}<Double>(Vector256<Double>, Vector256<Double>, Vector256<Double>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"   firstOp: ({string.Join(", ", firstOp)})");
@@ -424,6 +431,8 @@ private void ValidateResult(Double[] firstOp, Double[] secondOp, Double[] thirdO
                 TestLibrary.TestFramework.LogInformation($"   thirdOp: ({string.Join(", ", thirdOp)})");
                 TestLibrary.TestFramework.LogInformation($"    result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Fma_Vector256/MultiplyAdd.Single.cs b/tests/src/JIT/HardwareIntrinsics/X86/Fma_Vector256/MultiplyAdd.Single.cs
index 985df3df7958..f555c58f1bba 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Fma_Vector256/MultiplyAdd.Single.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Fma_Vector256/MultiplyAdd.Single.cs
@@ -356,7 +356,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -364,7 +364,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -400,9 +405,11 @@ private void ValidateResult(void* firstOp, void* secondOp, void* thirdOp, void*
 
         private void ValidateResult(Single[] firstOp, Single[] secondOp, Single[] thirdOp, Single[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (BitConverter.SingleToInt32Bits(MathF.Round((firstOp[0] * secondOp[0]) + thirdOp[0], 3)) != BitConverter.SingleToInt32Bits(MathF.Round(result[0], 3)))
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -410,13 +417,13 @@ private void ValidateResult(Single[] firstOp, Single[] secondOp, Single[] thirdO
                 {
                     if (BitConverter.SingleToInt32Bits(MathF.Round((firstOp[i] * secondOp[i]) + thirdOp[i], 3)) != BitConverter.SingleToInt32Bits(MathF.Round(result[i], 3)))
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Fma)}.{nameof(Fma.MultiplyAdd)}<Single>(Vector256<Single>, Vector256<Single>, Vector256<Single>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"   firstOp: ({string.Join(", ", firstOp)})");
@@ -424,6 +431,8 @@ private void ValidateResult(Single[] firstOp, Single[] secondOp, Single[] thirdO
                 TestLibrary.TestFramework.LogInformation($"   thirdOp: ({string.Join(", ", thirdOp)})");
                 TestLibrary.TestFramework.LogInformation($"    result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Fma_Vector256/MultiplyAddNegated.Double.cs b/tests/src/JIT/HardwareIntrinsics/X86/Fma_Vector256/MultiplyAddNegated.Double.cs
index 19d4ff5b95f6..68012d0470d6 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Fma_Vector256/MultiplyAddNegated.Double.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Fma_Vector256/MultiplyAddNegated.Double.cs
@@ -356,7 +356,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -364,7 +364,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -400,9 +405,11 @@ private void ValidateResult(void* firstOp, void* secondOp, void* thirdOp, void*
 
         private void ValidateResult(Double[] firstOp, Double[] secondOp, Double[] thirdOp, Double[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (BitConverter.DoubleToInt64Bits(Math.Round(-(firstOp[0] * secondOp[0]) + thirdOp[0], 9)) != BitConverter.DoubleToInt64Bits(Math.Round(result[0], 9)))
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -410,13 +417,13 @@ private void ValidateResult(Double[] firstOp, Double[] secondOp, Double[] thirdO
                 {
                     if (BitConverter.DoubleToInt64Bits(Math.Round(-(firstOp[i] * secondOp[i]) + thirdOp[i], 9)) != BitConverter.DoubleToInt64Bits(Math.Round(result[i], 9)))
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Fma)}.{nameof(Fma.MultiplyAddNegated)}<Double>(Vector256<Double>, Vector256<Double>, Vector256<Double>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"   firstOp: ({string.Join(", ", firstOp)})");
@@ -424,6 +431,8 @@ private void ValidateResult(Double[] firstOp, Double[] secondOp, Double[] thirdO
                 TestLibrary.TestFramework.LogInformation($"   thirdOp: ({string.Join(", ", thirdOp)})");
                 TestLibrary.TestFramework.LogInformation($"    result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Fma_Vector256/MultiplyAddNegated.Single.cs b/tests/src/JIT/HardwareIntrinsics/X86/Fma_Vector256/MultiplyAddNegated.Single.cs
index 4ffe8bb586ac..d041c7acd417 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Fma_Vector256/MultiplyAddNegated.Single.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Fma_Vector256/MultiplyAddNegated.Single.cs
@@ -356,7 +356,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -364,7 +364,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -400,9 +405,11 @@ private void ValidateResult(void* firstOp, void* secondOp, void* thirdOp, void*
 
         private void ValidateResult(Single[] firstOp, Single[] secondOp, Single[] thirdOp, Single[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (BitConverter.SingleToInt32Bits(MathF.Round(-(firstOp[0] * secondOp[0]) + thirdOp[0], 3)) != BitConverter.SingleToInt32Bits(MathF.Round(result[0], 3)))
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -410,13 +417,13 @@ private void ValidateResult(Single[] firstOp, Single[] secondOp, Single[] thirdO
                 {
                     if (BitConverter.SingleToInt32Bits(MathF.Round(-(firstOp[i] * secondOp[i]) + thirdOp[i], 3)) != BitConverter.SingleToInt32Bits(MathF.Round(result[i], 3)))
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Fma)}.{nameof(Fma.MultiplyAddNegated)}<Single>(Vector256<Single>, Vector256<Single>, Vector256<Single>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"   firstOp: ({string.Join(", ", firstOp)})");
@@ -424,6 +431,8 @@ private void ValidateResult(Single[] firstOp, Single[] secondOp, Single[] thirdO
                 TestLibrary.TestFramework.LogInformation($"   thirdOp: ({string.Join(", ", thirdOp)})");
                 TestLibrary.TestFramework.LogInformation($"    result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Fma_Vector256/MultiplyAddSubtract.Double.cs b/tests/src/JIT/HardwareIntrinsics/X86/Fma_Vector256/MultiplyAddSubtract.Double.cs
index 1d56a8f7e7ba..b3132bafcce5 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Fma_Vector256/MultiplyAddSubtract.Double.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Fma_Vector256/MultiplyAddSubtract.Double.cs
@@ -356,7 +356,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -364,7 +364,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -400,22 +405,24 @@ private void ValidateResult(void* firstOp, void* secondOp, void* thirdOp, void*
 
         private void ValidateResult(Double[] firstOp, Double[] secondOp, Double[] thirdOp, Double[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             for (var i = 0; i < RetElementCount; i += 2)
             {
                 if (BitConverter.DoubleToInt64Bits(Math.Round((firstOp[i] * secondOp[i]) - thirdOp[i], 9)) != BitConverter.DoubleToInt64Bits(Math.Round(result[i], 9)))
                 {
-                    Succeeded = false;
+                    succeeded = false;
                     break;
                 }
 
                 if (BitConverter.DoubleToInt64Bits(Math.Round((firstOp[i + 1] * secondOp[i + 1]) + thirdOp[i + 1], 9)) != BitConverter.DoubleToInt64Bits(Math.Round(result[i + 1], 9)))
                 {
-                    Succeeded = false;
+                    succeeded = false;
                     break;
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Fma)}.{nameof(Fma.MultiplyAddSubtract)}<Double>(Vector256<Double>, Vector256<Double>, Vector256<Double>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"   firstOp: ({string.Join(", ", firstOp)})");
@@ -423,6 +430,8 @@ private void ValidateResult(Double[] firstOp, Double[] secondOp, Double[] thirdO
                 TestLibrary.TestFramework.LogInformation($"   thirdOp: ({string.Join(", ", thirdOp)})");
                 TestLibrary.TestFramework.LogInformation($"    result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Fma_Vector256/MultiplyAddSubtract.Single.cs b/tests/src/JIT/HardwareIntrinsics/X86/Fma_Vector256/MultiplyAddSubtract.Single.cs
index 902eea9cb9bf..6816cfa4a33c 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Fma_Vector256/MultiplyAddSubtract.Single.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Fma_Vector256/MultiplyAddSubtract.Single.cs
@@ -356,7 +356,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -364,7 +364,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -400,22 +405,24 @@ private void ValidateResult(void* firstOp, void* secondOp, void* thirdOp, void*
 
         private void ValidateResult(Single[] firstOp, Single[] secondOp, Single[] thirdOp, Single[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             for (var i = 0; i < RetElementCount; i += 2)
             {
                 if (BitConverter.SingleToInt32Bits(MathF.Round((firstOp[i] * secondOp[i]) - thirdOp[i], 3)) != BitConverter.SingleToInt32Bits(MathF.Round(result[i], 3)))
                 {
-                    Succeeded = false;
+                    succeeded = false;
                     break;
                 }
 
                 if (BitConverter.SingleToInt32Bits(MathF.Round((firstOp[i + 1] * secondOp[i + 1]) + thirdOp[i + 1], 3)) != BitConverter.SingleToInt32Bits(MathF.Round(result[i + 1], 3)))
                 {
-                    Succeeded = false;
+                    succeeded = false;
                     break;
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Fma)}.{nameof(Fma.MultiplyAddSubtract)}<Single>(Vector256<Single>, Vector256<Single>, Vector256<Single>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"   firstOp: ({string.Join(", ", firstOp)})");
@@ -423,6 +430,8 @@ private void ValidateResult(Single[] firstOp, Single[] secondOp, Single[] thirdO
                 TestLibrary.TestFramework.LogInformation($"   thirdOp: ({string.Join(", ", thirdOp)})");
                 TestLibrary.TestFramework.LogInformation($"    result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Fma_Vector256/MultiplySubtract.Double.cs b/tests/src/JIT/HardwareIntrinsics/X86/Fma_Vector256/MultiplySubtract.Double.cs
index 1320f504fff0..26b052518cba 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Fma_Vector256/MultiplySubtract.Double.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Fma_Vector256/MultiplySubtract.Double.cs
@@ -356,7 +356,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -364,7 +364,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -400,9 +405,11 @@ private void ValidateResult(void* firstOp, void* secondOp, void* thirdOp, void*
 
         private void ValidateResult(Double[] firstOp, Double[] secondOp, Double[] thirdOp, Double[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (BitConverter.DoubleToInt64Bits(Math.Round((firstOp[0] * secondOp[0]) - thirdOp[0], 9)) != BitConverter.DoubleToInt64Bits(Math.Round(result[0], 9)))
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -410,13 +417,13 @@ private void ValidateResult(Double[] firstOp, Double[] secondOp, Double[] thirdO
                 {
                     if (BitConverter.DoubleToInt64Bits(Math.Round((firstOp[i] * secondOp[i]) - thirdOp[i], 9)) != BitConverter.DoubleToInt64Bits(Math.Round(result[i], 9)))
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Fma)}.{nameof(Fma.MultiplySubtract)}<Double>(Vector256<Double>, Vector256<Double>, Vector256<Double>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"   firstOp: ({string.Join(", ", firstOp)})");
@@ -424,6 +431,8 @@ private void ValidateResult(Double[] firstOp, Double[] secondOp, Double[] thirdO
                 TestLibrary.TestFramework.LogInformation($"   thirdOp: ({string.Join(", ", thirdOp)})");
                 TestLibrary.TestFramework.LogInformation($"    result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Fma_Vector256/MultiplySubtract.Single.cs b/tests/src/JIT/HardwareIntrinsics/X86/Fma_Vector256/MultiplySubtract.Single.cs
index bced88dff0d8..0c81d6bd71bb 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Fma_Vector256/MultiplySubtract.Single.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Fma_Vector256/MultiplySubtract.Single.cs
@@ -356,7 +356,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -364,7 +364,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -400,9 +405,11 @@ private void ValidateResult(void* firstOp, void* secondOp, void* thirdOp, void*
 
         private void ValidateResult(Single[] firstOp, Single[] secondOp, Single[] thirdOp, Single[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (BitConverter.SingleToInt32Bits(MathF.Round((firstOp[0] * secondOp[0]) - thirdOp[0], 3)) != BitConverter.SingleToInt32Bits(MathF.Round(result[0], 3)))
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -410,13 +417,13 @@ private void ValidateResult(Single[] firstOp, Single[] secondOp, Single[] thirdO
                 {
                     if (BitConverter.SingleToInt32Bits(MathF.Round((firstOp[i] * secondOp[i]) - thirdOp[i], 3)) != BitConverter.SingleToInt32Bits(MathF.Round(result[i], 3)))
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Fma)}.{nameof(Fma.MultiplySubtract)}<Single>(Vector256<Single>, Vector256<Single>, Vector256<Single>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"   firstOp: ({string.Join(", ", firstOp)})");
@@ -424,6 +431,8 @@ private void ValidateResult(Single[] firstOp, Single[] secondOp, Single[] thirdO
                 TestLibrary.TestFramework.LogInformation($"   thirdOp: ({string.Join(", ", thirdOp)})");
                 TestLibrary.TestFramework.LogInformation($"    result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Fma_Vector256/MultiplySubtractAdd.Double.cs b/tests/src/JIT/HardwareIntrinsics/X86/Fma_Vector256/MultiplySubtractAdd.Double.cs
index 1fa290f7848b..964006f6ad67 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Fma_Vector256/MultiplySubtractAdd.Double.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Fma_Vector256/MultiplySubtractAdd.Double.cs
@@ -356,7 +356,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -364,7 +364,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -400,22 +405,24 @@ private void ValidateResult(void* firstOp, void* secondOp, void* thirdOp, void*
 
         private void ValidateResult(Double[] firstOp, Double[] secondOp, Double[] thirdOp, Double[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             for (var i = 0; i < RetElementCount; i += 2)
             {
                 if (BitConverter.DoubleToInt64Bits(Math.Round((firstOp[i] * secondOp[i]) + thirdOp[i], 9)) != BitConverter.DoubleToInt64Bits(Math.Round(result[i], 9)))
                 {
-                    Succeeded = false;
+                    succeeded = false;
                     break;
                 }
 
                 if (BitConverter.DoubleToInt64Bits(Math.Round((firstOp[i + 1] * secondOp[i + 1]) - thirdOp[i + 1], 9)) != BitConverter.DoubleToInt64Bits(Math.Round(result[i + 1], 9)))
                 {
-                    Succeeded = false;
+                    succeeded = false;
                     break;
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Fma)}.{nameof(Fma.MultiplySubtractAdd)}<Double>(Vector256<Double>, Vector256<Double>, Vector256<Double>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"   firstOp: ({string.Join(", ", firstOp)})");
@@ -423,6 +430,8 @@ private void ValidateResult(Double[] firstOp, Double[] secondOp, Double[] thirdO
                 TestLibrary.TestFramework.LogInformation($"   thirdOp: ({string.Join(", ", thirdOp)})");
                 TestLibrary.TestFramework.LogInformation($"    result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Fma_Vector256/MultiplySubtractAdd.Single.cs b/tests/src/JIT/HardwareIntrinsics/X86/Fma_Vector256/MultiplySubtractAdd.Single.cs
index 8d5c762d1a71..930138a5f725 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Fma_Vector256/MultiplySubtractAdd.Single.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Fma_Vector256/MultiplySubtractAdd.Single.cs
@@ -356,7 +356,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -364,7 +364,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -400,22 +405,24 @@ private void ValidateResult(void* firstOp, void* secondOp, void* thirdOp, void*
 
         private void ValidateResult(Single[] firstOp, Single[] secondOp, Single[] thirdOp, Single[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             for (var i = 0; i < RetElementCount; i += 2)
             {
                 if (BitConverter.SingleToInt32Bits(MathF.Round((firstOp[i] * secondOp[i]) + thirdOp[i], 3)) != BitConverter.SingleToInt32Bits(MathF.Round(result[i], 3)))
                 {
-                    Succeeded = false;
+                    succeeded = false;
                     break;
                 }
 
                 if (BitConverter.SingleToInt32Bits(MathF.Round((firstOp[i + 1] * secondOp[i + 1]) - thirdOp[i + 1], 3)) != BitConverter.SingleToInt32Bits(MathF.Round(result[i + 1], 3)))
                 {
-                    Succeeded = false;
+                    succeeded = false;
                     break;
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Fma)}.{nameof(Fma.MultiplySubtractAdd)}<Single>(Vector256<Single>, Vector256<Single>, Vector256<Single>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"   firstOp: ({string.Join(", ", firstOp)})");
@@ -423,6 +430,8 @@ private void ValidateResult(Single[] firstOp, Single[] secondOp, Single[] thirdO
                 TestLibrary.TestFramework.LogInformation($"   thirdOp: ({string.Join(", ", thirdOp)})");
                 TestLibrary.TestFramework.LogInformation($"    result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Fma_Vector256/MultiplySubtractNegated.Double.cs b/tests/src/JIT/HardwareIntrinsics/X86/Fma_Vector256/MultiplySubtractNegated.Double.cs
index 17b5381ea66a..365f1d020277 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Fma_Vector256/MultiplySubtractNegated.Double.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Fma_Vector256/MultiplySubtractNegated.Double.cs
@@ -356,7 +356,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -364,7 +364,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -400,9 +405,11 @@ private void ValidateResult(void* firstOp, void* secondOp, void* thirdOp, void*
 
         private void ValidateResult(Double[] firstOp, Double[] secondOp, Double[] thirdOp, Double[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (BitConverter.DoubleToInt64Bits(Math.Round(-(firstOp[0] * secondOp[0]) - thirdOp[0], 9)) != BitConverter.DoubleToInt64Bits(Math.Round(result[0], 9)))
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -410,13 +417,13 @@ private void ValidateResult(Double[] firstOp, Double[] secondOp, Double[] thirdO
                 {
                     if (BitConverter.DoubleToInt64Bits(Math.Round(-(firstOp[i] * secondOp[i]) - thirdOp[i], 9)) != BitConverter.DoubleToInt64Bits(Math.Round(result[i], 9)))
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Fma)}.{nameof(Fma.MultiplySubtractNegated)}<Double>(Vector256<Double>, Vector256<Double>, Vector256<Double>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"   firstOp: ({string.Join(", ", firstOp)})");
@@ -424,6 +431,8 @@ private void ValidateResult(Double[] firstOp, Double[] secondOp, Double[] thirdO
                 TestLibrary.TestFramework.LogInformation($"   thirdOp: ({string.Join(", ", thirdOp)})");
                 TestLibrary.TestFramework.LogInformation($"    result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Fma_Vector256/MultiplySubtractNegated.Single.cs b/tests/src/JIT/HardwareIntrinsics/X86/Fma_Vector256/MultiplySubtractNegated.Single.cs
index def77d8a5d71..a0ac1c1a2d59 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Fma_Vector256/MultiplySubtractNegated.Single.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Fma_Vector256/MultiplySubtractNegated.Single.cs
@@ -356,7 +356,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -364,7 +364,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -400,9 +405,11 @@ private void ValidateResult(void* firstOp, void* secondOp, void* thirdOp, void*
 
         private void ValidateResult(Single[] firstOp, Single[] secondOp, Single[] thirdOp, Single[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (BitConverter.SingleToInt32Bits(MathF.Round(-(firstOp[0] * secondOp[0]) - thirdOp[0], 3)) != BitConverter.SingleToInt32Bits(MathF.Round(result[0], 3)))
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -410,13 +417,13 @@ private void ValidateResult(Single[] firstOp, Single[] secondOp, Single[] thirdO
                 {
                     if (BitConverter.SingleToInt32Bits(MathF.Round(-(firstOp[i] * secondOp[i]) - thirdOp[i], 3)) != BitConverter.SingleToInt32Bits(MathF.Round(result[i], 3)))
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Fma)}.{nameof(Fma.MultiplySubtractNegated)}<Single>(Vector256<Single>, Vector256<Single>, Vector256<Single>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"   firstOp: ({string.Join(", ", firstOp)})");
@@ -424,6 +431,8 @@ private void ValidateResult(Single[] firstOp, Single[] secondOp, Single[] thirdO
                 TestLibrary.TestFramework.LogInformation($"   thirdOp: ({string.Join(", ", thirdOp)})");
                 TestLibrary.TestFramework.LogInformation($"    result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Pclmulqdq/CarrylessMultiply.Int64.0.cs b/tests/src/JIT/HardwareIntrinsics/X86/Pclmulqdq/CarrylessMultiply.Int64.0.cs
index ee8eda6c387c..78e2280d2a91 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Pclmulqdq/CarrylessMultiply.Int64.0.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Pclmulqdq/CarrylessMultiply.Int64.0.cs
@@ -334,7 +334,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -342,7 +342,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -358,19 +363,24 @@ private void ValidateResult(void* result, [CallerMemberName] string method = "")
 
         private void ValidateResult(Int64[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             for (int i = 0; i < result.Length; i++)
             {
                 if (result[i] != _expectedRet[i] )
                 {
-                    Succeeded = false;
+                    succeeded = false;
                 } 
             }
-            if (!Succeeded)
+
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Pclmulqdq)}.{nameof(Pclmulqdq.CarrylessMultiply)}<Int64>(Vector128<Int64>, 0): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"  expectedRet: ({string.Join(", ", _expectedRet)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
 
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Pclmulqdq/CarrylessMultiply.Int64.1.cs b/tests/src/JIT/HardwareIntrinsics/X86/Pclmulqdq/CarrylessMultiply.Int64.1.cs
index de31aa0cfa4a..034675d3f829 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Pclmulqdq/CarrylessMultiply.Int64.1.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Pclmulqdq/CarrylessMultiply.Int64.1.cs
@@ -334,7 +334,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -342,7 +342,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -358,19 +363,24 @@ private void ValidateResult(void* result, [CallerMemberName] string method = "")
 
         private void ValidateResult(Int64[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             for (int i = 0; i < result.Length; i++)
             {
                 if (result[i] != _expectedRet[i] )
                 {
-                    Succeeded = false;
+                    succeeded = false;
                 } 
             }
-            if (!Succeeded)
+
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Pclmulqdq)}.{nameof(Pclmulqdq.CarrylessMultiply)}<Int64>(Vector128<Int64>, 1): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"  expectedRet: ({string.Join(", ", _expectedRet)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
 
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Pclmulqdq/CarrylessMultiply.Int64.129.cs b/tests/src/JIT/HardwareIntrinsics/X86/Pclmulqdq/CarrylessMultiply.Int64.129.cs
index 76be93f69acc..9f19b5dbfe6d 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Pclmulqdq/CarrylessMultiply.Int64.129.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Pclmulqdq/CarrylessMultiply.Int64.129.cs
@@ -334,7 +334,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -342,7 +342,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -358,19 +363,24 @@ private void ValidateResult(void* result, [CallerMemberName] string method = "")
 
         private void ValidateResult(Int64[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             for (int i = 0; i < result.Length; i++)
             {
                 if (result[i] != _expectedRet[i] )
                 {
-                    Succeeded = false;
+                    succeeded = false;
                 } 
             }
-            if (!Succeeded)
+
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Pclmulqdq)}.{nameof(Pclmulqdq.CarrylessMultiply)}<Int64>(Vector128<Int64>, 129): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"  expectedRet: ({string.Join(", ", _expectedRet)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
 
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Pclmulqdq/CarrylessMultiply.Int64.16.cs b/tests/src/JIT/HardwareIntrinsics/X86/Pclmulqdq/CarrylessMultiply.Int64.16.cs
index d5b2f311d1dc..01692e596181 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Pclmulqdq/CarrylessMultiply.Int64.16.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Pclmulqdq/CarrylessMultiply.Int64.16.cs
@@ -334,7 +334,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -342,7 +342,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -358,19 +363,24 @@ private void ValidateResult(void* result, [CallerMemberName] string method = "")
 
         private void ValidateResult(Int64[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             for (int i = 0; i < result.Length; i++)
             {
                 if (result[i] != _expectedRet[i] )
                 {
-                    Succeeded = false;
+                    succeeded = false;
                 } 
             }
-            if (!Succeeded)
+
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Pclmulqdq)}.{nameof(Pclmulqdq.CarrylessMultiply)}<Int64>(Vector128<Int64>, 16): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"  expectedRet: ({string.Join(", ", _expectedRet)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
 
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Pclmulqdq/CarrylessMultiply.Int64.17.cs b/tests/src/JIT/HardwareIntrinsics/X86/Pclmulqdq/CarrylessMultiply.Int64.17.cs
index 990b446ef615..3c97a4a071f2 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Pclmulqdq/CarrylessMultiply.Int64.17.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Pclmulqdq/CarrylessMultiply.Int64.17.cs
@@ -334,7 +334,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -342,7 +342,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -358,19 +363,24 @@ private void ValidateResult(void* result, [CallerMemberName] string method = "")
 
         private void ValidateResult(Int64[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             for (int i = 0; i < result.Length; i++)
             {
                 if (result[i] != _expectedRet[i] )
                 {
-                    Succeeded = false;
+                    succeeded = false;
                 } 
             }
-            if (!Succeeded)
+
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Pclmulqdq)}.{nameof(Pclmulqdq.CarrylessMultiply)}<Int64>(Vector128<Int64>, 17): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"  expectedRet: ({string.Join(", ", _expectedRet)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
 
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Pclmulqdq/CarrylessMultiply.UInt64.0.cs b/tests/src/JIT/HardwareIntrinsics/X86/Pclmulqdq/CarrylessMultiply.UInt64.0.cs
index 450281140d85..27a3f61ebc85 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Pclmulqdq/CarrylessMultiply.UInt64.0.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Pclmulqdq/CarrylessMultiply.UInt64.0.cs
@@ -334,7 +334,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -342,7 +342,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -358,19 +363,24 @@ private void ValidateResult(void* result, [CallerMemberName] string method = "")
 
         private void ValidateResult(UInt64[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             for (int i = 0; i < result.Length; i++)
             {
                 if (result[i] != _expectedRet[i] )
                 {
-                    Succeeded = false;
+                    succeeded = false;
                 } 
             }
-            if (!Succeeded)
+
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Pclmulqdq)}.{nameof(Pclmulqdq.CarrylessMultiply)}<UInt64>(Vector128<UInt64>, 0): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"  expectedRet: ({string.Join(", ", _expectedRet)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
 
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Pclmulqdq/CarrylessMultiply.UInt64.1.cs b/tests/src/JIT/HardwareIntrinsics/X86/Pclmulqdq/CarrylessMultiply.UInt64.1.cs
index f267e19c9cea..d68924642326 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Pclmulqdq/CarrylessMultiply.UInt64.1.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Pclmulqdq/CarrylessMultiply.UInt64.1.cs
@@ -334,7 +334,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -342,7 +342,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -358,19 +363,24 @@ private void ValidateResult(void* result, [CallerMemberName] string method = "")
 
         private void ValidateResult(UInt64[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             for (int i = 0; i < result.Length; i++)
             {
                 if (result[i] != _expectedRet[i] )
                 {
-                    Succeeded = false;
+                    succeeded = false;
                 } 
             }
-            if (!Succeeded)
+
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Pclmulqdq)}.{nameof(Pclmulqdq.CarrylessMultiply)}<UInt64>(Vector128<UInt64>, 1): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"  expectedRet: ({string.Join(", ", _expectedRet)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
 
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Pclmulqdq/CarrylessMultiply.UInt64.129.cs b/tests/src/JIT/HardwareIntrinsics/X86/Pclmulqdq/CarrylessMultiply.UInt64.129.cs
index b5b5e9e31a6b..8a89dda9430f 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Pclmulqdq/CarrylessMultiply.UInt64.129.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Pclmulqdq/CarrylessMultiply.UInt64.129.cs
@@ -334,7 +334,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -342,7 +342,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -358,19 +363,24 @@ private void ValidateResult(void* result, [CallerMemberName] string method = "")
 
         private void ValidateResult(UInt64[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             for (int i = 0; i < result.Length; i++)
             {
                 if (result[i] != _expectedRet[i] )
                 {
-                    Succeeded = false;
+                    succeeded = false;
                 } 
             }
-            if (!Succeeded)
+
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Pclmulqdq)}.{nameof(Pclmulqdq.CarrylessMultiply)}<UInt64>(Vector128<UInt64>, 129): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"  expectedRet: ({string.Join(", ", _expectedRet)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
 
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Pclmulqdq/CarrylessMultiply.UInt64.16.cs b/tests/src/JIT/HardwareIntrinsics/X86/Pclmulqdq/CarrylessMultiply.UInt64.16.cs
index a662ef3816d2..92ee3ec2940e 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Pclmulqdq/CarrylessMultiply.UInt64.16.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Pclmulqdq/CarrylessMultiply.UInt64.16.cs
@@ -334,7 +334,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -342,7 +342,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -358,19 +363,24 @@ private void ValidateResult(void* result, [CallerMemberName] string method = "")
 
         private void ValidateResult(UInt64[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             for (int i = 0; i < result.Length; i++)
             {
                 if (result[i] != _expectedRet[i] )
                 {
-                    Succeeded = false;
+                    succeeded = false;
                 } 
             }
-            if (!Succeeded)
+
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Pclmulqdq)}.{nameof(Pclmulqdq.CarrylessMultiply)}<UInt64>(Vector128<UInt64>, 16): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"  expectedRet: ({string.Join(", ", _expectedRet)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
 
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Pclmulqdq/CarrylessMultiply.UInt64.17.cs b/tests/src/JIT/HardwareIntrinsics/X86/Pclmulqdq/CarrylessMultiply.UInt64.17.cs
index 29b007249791..82946e4001bc 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Pclmulqdq/CarrylessMultiply.UInt64.17.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Pclmulqdq/CarrylessMultiply.UInt64.17.cs
@@ -334,7 +334,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -342,7 +342,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -358,19 +363,24 @@ private void ValidateResult(void* result, [CallerMemberName] string method = "")
 
         private void ValidateResult(UInt64[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             for (int i = 0; i < result.Length; i++)
             {
                 if (result[i] != _expectedRet[i] )
                 {
-                    Succeeded = false;
+                    succeeded = false;
                 } 
             }
-            if (!Succeeded)
+
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Pclmulqdq)}.{nameof(Pclmulqdq.CarrylessMultiply)}<UInt64>(Vector128<UInt64>, 17): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"  expectedRet: ({string.Join(", ", _expectedRet)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
 
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse/Add.Single.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse/Add.Single.cs
index 060812f83d87..f5a0fa340a07 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Sse/Add.Single.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse/Add.Single.cs
@@ -334,7 +334,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -342,7 +342,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -374,9 +379,11 @@ private void ValidateResult(void* left, void* right, void* result, [CallerMember
 
         private void ValidateResult(Single[] left, Single[] right, Single[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (BitConverter.SingleToInt32Bits(left[0] + right[0]) != BitConverter.SingleToInt32Bits(result[0]))
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -384,19 +391,21 @@ private void ValidateResult(Single[] left, Single[] right, Single[] result, [Cal
                 {
                     if (BitConverter.SingleToInt32Bits(left[i] + right[i]) != BitConverter.SingleToInt32Bits(result[i]))
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Sse)}.{nameof(Sse.Add)}<Single>(Vector128<Single>, Vector128<Single>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse/AddScalar.Single.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse/AddScalar.Single.cs
index a071420c6cef..9441aadb4ad5 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Sse/AddScalar.Single.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse/AddScalar.Single.cs
@@ -334,7 +334,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -342,7 +342,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -374,9 +379,11 @@ private void ValidateResult(void* left, void* right, void* result, [CallerMember
 
         private void ValidateResult(Single[] left, Single[] right, Single[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (BitConverter.SingleToInt32Bits(left[0] + right[0]) != BitConverter.SingleToInt32Bits(result[0]))
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -384,19 +391,21 @@ private void ValidateResult(Single[] left, Single[] right, Single[] result, [Cal
                 {
                     if (BitConverter.SingleToInt32Bits(left[i]) != BitConverter.SingleToInt32Bits(result[i]))
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Sse)}.{nameof(Sse.AddScalar)}<Single>(Vector128<Single>, Vector128<Single>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse/And.Single.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse/And.Single.cs
index 77c00aead924..15f4299e672a 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Sse/And.Single.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse/And.Single.cs
@@ -334,7 +334,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -342,7 +342,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -374,9 +379,11 @@ private void ValidateResult(void* left, void* right, void* result, [CallerMember
 
         private void ValidateResult(Single[] left, Single[] right, Single[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if ((BitConverter.SingleToInt32Bits(left[0]) & BitConverter.SingleToInt32Bits(right[0])) != BitConverter.SingleToInt32Bits(result[0]))
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -384,19 +391,21 @@ private void ValidateResult(Single[] left, Single[] right, Single[] result, [Cal
                 {
                     if ((BitConverter.SingleToInt32Bits(left[0]) & BitConverter.SingleToInt32Bits(right[0])) != BitConverter.SingleToInt32Bits(result[0]))
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Sse)}.{nameof(Sse.And)}<Single>(Vector128<Single>, Vector128<Single>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse/AndNot.Single.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse/AndNot.Single.cs
index 971b3fb72f22..d3536b176668 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Sse/AndNot.Single.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse/AndNot.Single.cs
@@ -334,7 +334,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -342,7 +342,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -374,9 +379,11 @@ private void ValidateResult(void* left, void* right, void* result, [CallerMember
 
         private void ValidateResult(Single[] left, Single[] right, Single[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if ((~BitConverter.SingleToInt32Bits(left[0]) & BitConverter.SingleToInt32Bits(right[0])) != BitConverter.SingleToInt32Bits(result[0]))
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -384,19 +391,21 @@ private void ValidateResult(Single[] left, Single[] right, Single[] result, [Cal
                 {
                     if ((~BitConverter.SingleToInt32Bits(left[0]) & BitConverter.SingleToInt32Bits(right[0])) != BitConverter.SingleToInt32Bits(result[0]))
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Sse)}.{nameof(Sse.AndNot)}<Single>(Vector128<Single>, Vector128<Single>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse/CompareEqual.Single.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse/CompareEqual.Single.cs
index 4a76f55be41e..18bdd239d981 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Sse/CompareEqual.Single.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse/CompareEqual.Single.cs
@@ -334,7 +334,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -342,7 +342,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -374,9 +379,11 @@ private void ValidateResult(void* left, void* right, void* result, [CallerMember
 
         private void ValidateResult(Single[] left, Single[] right, Single[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (BitConverter.SingleToInt32Bits(result[0]) != ((left[0] == right[0]) ? -1 : 0))
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -384,19 +391,21 @@ private void ValidateResult(Single[] left, Single[] right, Single[] result, [Cal
                 {
                     if (BitConverter.SingleToInt32Bits(result[i]) != ((left[i] == right[i]) ? -1 : 0))
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Sse)}.{nameof(Sse.CompareEqual)}<Single>(Vector128<Single>, Vector128<Single>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse/CompareEqualOrderedScalar.Boolean.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse/CompareEqualOrderedScalar.Boolean.cs
index 8100dd897cae..71d650b7b6b0 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Sse/CompareEqualOrderedScalar.Boolean.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse/CompareEqualOrderedScalar.Boolean.cs
@@ -317,7 +317,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -325,7 +325,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -355,13 +360,13 @@ private void ValidateResult(Single[] left, Single[] right, bool result, [CallerM
         {
             if ((left[0] == right[0]) != result)
             {
-                Succeeded = false;
-
                 TestLibrary.TestFramework.LogInformation($"{nameof(Sse)}.{nameof(Sse.CompareEqualOrderedScalar)}<Boolean>(Vector128<Single>, Vector128<Single>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse/CompareEqualScalar.Single.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse/CompareEqualScalar.Single.cs
index 1541aee6f62f..651130456d16 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Sse/CompareEqualScalar.Single.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse/CompareEqualScalar.Single.cs
@@ -334,7 +334,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -342,7 +342,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -374,9 +379,11 @@ private void ValidateResult(void* left, void* right, void* result, [CallerMember
 
         private void ValidateResult(Single[] left, Single[] right, Single[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (BitConverter.SingleToInt32Bits(result[0]) != ((left[0] == right[0]) ? -1 : 0))
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -384,19 +391,21 @@ private void ValidateResult(Single[] left, Single[] right, Single[] result, [Cal
                 {
                     if (BitConverter.SingleToInt32Bits(left[i]) != BitConverter.SingleToInt32Bits(result[i]))
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Sse)}.{nameof(Sse.CompareEqualScalar)}<Single>(Vector128<Single>, Vector128<Single>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse/CompareEqualUnorderedScalar.Boolean.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse/CompareEqualUnorderedScalar.Boolean.cs
index 9c4a44354083..535755efc8e9 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Sse/CompareEqualUnorderedScalar.Boolean.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse/CompareEqualUnorderedScalar.Boolean.cs
@@ -317,7 +317,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -325,7 +325,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -355,13 +360,13 @@ private void ValidateResult(Single[] left, Single[] right, bool result, [CallerM
         {
             if ((left[0] == right[0]) != result)
             {
-                Succeeded = false;
-
                 TestLibrary.TestFramework.LogInformation($"{nameof(Sse)}.{nameof(Sse.CompareEqualUnorderedScalar)}<Boolean>(Vector128<Single>, Vector128<Single>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse/CompareGreaterThan.Single.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse/CompareGreaterThan.Single.cs
index 354519083261..fc7aead94b4c 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Sse/CompareGreaterThan.Single.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse/CompareGreaterThan.Single.cs
@@ -334,7 +334,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -342,7 +342,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -374,9 +379,11 @@ private void ValidateResult(void* left, void* right, void* result, [CallerMember
 
         private void ValidateResult(Single[] left, Single[] right, Single[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (BitConverter.SingleToInt32Bits(result[0]) != ((left[0] > right[0]) ? -1 : 0))
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -384,19 +391,21 @@ private void ValidateResult(Single[] left, Single[] right, Single[] result, [Cal
                 {
                     if (BitConverter.SingleToInt32Bits(result[i]) != ((left[i] > right[i]) ? -1 : 0))
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Sse)}.{nameof(Sse.CompareGreaterThan)}<Single>(Vector128<Single>, Vector128<Single>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse/CompareGreaterThanOrEqual.Single.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse/CompareGreaterThanOrEqual.Single.cs
index 16a8a6900ad2..0dfbb1512eaa 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Sse/CompareGreaterThanOrEqual.Single.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse/CompareGreaterThanOrEqual.Single.cs
@@ -334,7 +334,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -342,7 +342,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -374,9 +379,11 @@ private void ValidateResult(void* left, void* right, void* result, [CallerMember
 
         private void ValidateResult(Single[] left, Single[] right, Single[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (BitConverter.SingleToInt32Bits(result[0]) != ((left[0] >= right[0]) ? -1 : 0))
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -384,19 +391,21 @@ private void ValidateResult(Single[] left, Single[] right, Single[] result, [Cal
                 {
                     if (BitConverter.SingleToInt32Bits(result[i]) != ((left[i] >= right[i]) ? -1 : 0))
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Sse)}.{nameof(Sse.CompareGreaterThanOrEqual)}<Single>(Vector128<Single>, Vector128<Single>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse/CompareGreaterThanOrEqualOrderedScalar.Boolean.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse/CompareGreaterThanOrEqualOrderedScalar.Boolean.cs
index 7e8e197ea35d..353e8f7290a7 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Sse/CompareGreaterThanOrEqualOrderedScalar.Boolean.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse/CompareGreaterThanOrEqualOrderedScalar.Boolean.cs
@@ -317,7 +317,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -325,7 +325,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -355,13 +360,13 @@ private void ValidateResult(Single[] left, Single[] right, bool result, [CallerM
         {
             if ((left[0] >= right[0]) != result)
             {
-                Succeeded = false;
-
                 TestLibrary.TestFramework.LogInformation($"{nameof(Sse)}.{nameof(Sse.CompareGreaterThanOrEqualOrderedScalar)}<Boolean>(Vector128<Single>, Vector128<Single>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse/CompareGreaterThanOrEqualScalar.Single.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse/CompareGreaterThanOrEqualScalar.Single.cs
index d7993b3997d5..cbd1834f2acb 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Sse/CompareGreaterThanOrEqualScalar.Single.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse/CompareGreaterThanOrEqualScalar.Single.cs
@@ -334,7 +334,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -342,7 +342,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -374,9 +379,11 @@ private void ValidateResult(void* left, void* right, void* result, [CallerMember
 
         private void ValidateResult(Single[] left, Single[] right, Single[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (BitConverter.SingleToInt32Bits(result[0]) != ((left[0] >= right[0]) ? -1 : 0))
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -384,19 +391,21 @@ private void ValidateResult(Single[] left, Single[] right, Single[] result, [Cal
                 {
                     if (BitConverter.SingleToInt32Bits(left[i]) != BitConverter.SingleToInt32Bits(result[i]))
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Sse)}.{nameof(Sse.CompareGreaterThanOrEqualScalar)}<Single>(Vector128<Single>, Vector128<Single>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse/CompareGreaterThanOrEqualUnorderedScalar.Boolean.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse/CompareGreaterThanOrEqualUnorderedScalar.Boolean.cs
index e9558ef9dab4..8d179b975c00 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Sse/CompareGreaterThanOrEqualUnorderedScalar.Boolean.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse/CompareGreaterThanOrEqualUnorderedScalar.Boolean.cs
@@ -317,7 +317,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -325,7 +325,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -355,13 +360,13 @@ private void ValidateResult(Single[] left, Single[] right, bool result, [CallerM
         {
             if ((left[0] >= right[0]) != result)
             {
-                Succeeded = false;
-
                 TestLibrary.TestFramework.LogInformation($"{nameof(Sse)}.{nameof(Sse.CompareGreaterThanOrEqualUnorderedScalar)}<Boolean>(Vector128<Single>, Vector128<Single>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse/CompareGreaterThanOrderedScalar.Boolean.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse/CompareGreaterThanOrderedScalar.Boolean.cs
index 20a7670b51a2..0ed6f13439ed 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Sse/CompareGreaterThanOrderedScalar.Boolean.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse/CompareGreaterThanOrderedScalar.Boolean.cs
@@ -317,7 +317,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -325,7 +325,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -355,13 +360,13 @@ private void ValidateResult(Single[] left, Single[] right, bool result, [CallerM
         {
             if ((left[0] > right[0]) != result)
             {
-                Succeeded = false;
-
                 TestLibrary.TestFramework.LogInformation($"{nameof(Sse)}.{nameof(Sse.CompareGreaterThanOrderedScalar)}<Boolean>(Vector128<Single>, Vector128<Single>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse/CompareGreaterThanScalar.Single.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse/CompareGreaterThanScalar.Single.cs
index 50ff5a898923..9304b69e1317 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Sse/CompareGreaterThanScalar.Single.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse/CompareGreaterThanScalar.Single.cs
@@ -334,7 +334,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -342,7 +342,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -374,9 +379,11 @@ private void ValidateResult(void* left, void* right, void* result, [CallerMember
 
         private void ValidateResult(Single[] left, Single[] right, Single[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (BitConverter.SingleToInt32Bits(result[0]) != ((left[0] > right[0]) ? -1 : 0))
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -384,19 +391,21 @@ private void ValidateResult(Single[] left, Single[] right, Single[] result, [Cal
                 {
                     if (BitConverter.SingleToInt32Bits(left[i]) != BitConverter.SingleToInt32Bits(result[i]))
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Sse)}.{nameof(Sse.CompareGreaterThanScalar)}<Single>(Vector128<Single>, Vector128<Single>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse/CompareGreaterThanUnorderedScalar.Boolean.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse/CompareGreaterThanUnorderedScalar.Boolean.cs
index 5bfd3cd46f25..da2ffd63c172 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Sse/CompareGreaterThanUnorderedScalar.Boolean.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse/CompareGreaterThanUnorderedScalar.Boolean.cs
@@ -317,7 +317,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -325,7 +325,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -355,13 +360,13 @@ private void ValidateResult(Single[] left, Single[] right, bool result, [CallerM
         {
             if ((left[0] > right[0]) != result)
             {
-                Succeeded = false;
-
                 TestLibrary.TestFramework.LogInformation($"{nameof(Sse)}.{nameof(Sse.CompareGreaterThanUnorderedScalar)}<Boolean>(Vector128<Single>, Vector128<Single>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse/CompareLessThan.Single.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse/CompareLessThan.Single.cs
index f2aaadebcac1..b1d0df065564 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Sse/CompareLessThan.Single.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse/CompareLessThan.Single.cs
@@ -334,7 +334,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -342,7 +342,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -374,9 +379,11 @@ private void ValidateResult(void* left, void* right, void* result, [CallerMember
 
         private void ValidateResult(Single[] left, Single[] right, Single[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (BitConverter.SingleToInt32Bits(result[0]) != ((left[0] < right[0]) ? -1 : 0))
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -384,19 +391,21 @@ private void ValidateResult(Single[] left, Single[] right, Single[] result, [Cal
                 {
                     if (BitConverter.SingleToInt32Bits(result[i]) != ((left[i] < right[i]) ? -1 : 0))
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Sse)}.{nameof(Sse.CompareLessThan)}<Single>(Vector128<Single>, Vector128<Single>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse/CompareLessThanOrEqual.Single.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse/CompareLessThanOrEqual.Single.cs
index a96162ed1c62..72c602d988e3 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Sse/CompareLessThanOrEqual.Single.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse/CompareLessThanOrEqual.Single.cs
@@ -334,7 +334,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -342,7 +342,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -374,9 +379,11 @@ private void ValidateResult(void* left, void* right, void* result, [CallerMember
 
         private void ValidateResult(Single[] left, Single[] right, Single[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (BitConverter.SingleToInt32Bits(result[0]) != ((left[0] <= right[0]) ? -1 : 0))
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -384,19 +391,21 @@ private void ValidateResult(Single[] left, Single[] right, Single[] result, [Cal
                 {
                     if (BitConverter.SingleToInt32Bits(result[i]) != ((left[i] <= right[i]) ? -1 : 0))
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Sse)}.{nameof(Sse.CompareLessThanOrEqual)}<Single>(Vector128<Single>, Vector128<Single>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse/CompareLessThanOrEqualOrderedScalar.Boolean.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse/CompareLessThanOrEqualOrderedScalar.Boolean.cs
index 361c43de6120..80c55e6fa55f 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Sse/CompareLessThanOrEqualOrderedScalar.Boolean.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse/CompareLessThanOrEqualOrderedScalar.Boolean.cs
@@ -317,7 +317,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -325,7 +325,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -355,13 +360,13 @@ private void ValidateResult(Single[] left, Single[] right, bool result, [CallerM
         {
             if ((left[0] <= right[0]) != result)
             {
-                Succeeded = false;
-
                 TestLibrary.TestFramework.LogInformation($"{nameof(Sse)}.{nameof(Sse.CompareLessThanOrEqualOrderedScalar)}<Boolean>(Vector128<Single>, Vector128<Single>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse/CompareLessThanOrEqualScalar.Single.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse/CompareLessThanOrEqualScalar.Single.cs
index abf85b16e6d3..a0fd41a14e67 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Sse/CompareLessThanOrEqualScalar.Single.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse/CompareLessThanOrEqualScalar.Single.cs
@@ -334,7 +334,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -342,7 +342,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -374,9 +379,11 @@ private void ValidateResult(void* left, void* right, void* result, [CallerMember
 
         private void ValidateResult(Single[] left, Single[] right, Single[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (BitConverter.SingleToInt32Bits(result[0]) != ((left[0] <= right[0]) ? -1 : 0))
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -384,19 +391,21 @@ private void ValidateResult(Single[] left, Single[] right, Single[] result, [Cal
                 {
                     if (BitConverter.SingleToInt32Bits(left[i]) != BitConverter.SingleToInt32Bits(result[i]))
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Sse)}.{nameof(Sse.CompareLessThanOrEqualScalar)}<Single>(Vector128<Single>, Vector128<Single>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse/CompareLessThanOrEqualUnorderedScalar.Boolean.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse/CompareLessThanOrEqualUnorderedScalar.Boolean.cs
index 8e497346d591..57e760167e3e 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Sse/CompareLessThanOrEqualUnorderedScalar.Boolean.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse/CompareLessThanOrEqualUnorderedScalar.Boolean.cs
@@ -317,7 +317,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -325,7 +325,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -355,13 +360,13 @@ private void ValidateResult(Single[] left, Single[] right, bool result, [CallerM
         {
             if ((left[0] <= right[0]) != result)
             {
-                Succeeded = false;
-
                 TestLibrary.TestFramework.LogInformation($"{nameof(Sse)}.{nameof(Sse.CompareLessThanOrEqualUnorderedScalar)}<Boolean>(Vector128<Single>, Vector128<Single>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse/CompareLessThanOrderedScalar.Boolean.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse/CompareLessThanOrderedScalar.Boolean.cs
index 368e3965945a..d0bb4fa3842f 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Sse/CompareLessThanOrderedScalar.Boolean.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse/CompareLessThanOrderedScalar.Boolean.cs
@@ -317,7 +317,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -325,7 +325,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -355,13 +360,13 @@ private void ValidateResult(Single[] left, Single[] right, bool result, [CallerM
         {
             if ((left[0] < right[0]) != result)
             {
-                Succeeded = false;
-
                 TestLibrary.TestFramework.LogInformation($"{nameof(Sse)}.{nameof(Sse.CompareLessThanOrderedScalar)}<Boolean>(Vector128<Single>, Vector128<Single>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse/CompareLessThanScalar.Single.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse/CompareLessThanScalar.Single.cs
index d78bdb098f00..51ae3aae9490 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Sse/CompareLessThanScalar.Single.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse/CompareLessThanScalar.Single.cs
@@ -334,7 +334,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -342,7 +342,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -374,9 +379,11 @@ private void ValidateResult(void* left, void* right, void* result, [CallerMember
 
         private void ValidateResult(Single[] left, Single[] right, Single[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (BitConverter.SingleToInt32Bits(result[0]) != ((left[0] < right[0]) ? -1 : 0))
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -384,19 +391,21 @@ private void ValidateResult(Single[] left, Single[] right, Single[] result, [Cal
                 {
                     if (BitConverter.SingleToInt32Bits(left[i]) != BitConverter.SingleToInt32Bits(result[i]))
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Sse)}.{nameof(Sse.CompareLessThanScalar)}<Single>(Vector128<Single>, Vector128<Single>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse/CompareLessThanUnorderedScalar.Boolean.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse/CompareLessThanUnorderedScalar.Boolean.cs
index d1e6a3c5bb4f..d6afcb9f3f5e 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Sse/CompareLessThanUnorderedScalar.Boolean.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse/CompareLessThanUnorderedScalar.Boolean.cs
@@ -317,7 +317,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -325,7 +325,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -355,13 +360,13 @@ private void ValidateResult(Single[] left, Single[] right, bool result, [CallerM
         {
             if ((left[0] < right[0]) != result)
             {
-                Succeeded = false;
-
                 TestLibrary.TestFramework.LogInformation($"{nameof(Sse)}.{nameof(Sse.CompareLessThanUnorderedScalar)}<Boolean>(Vector128<Single>, Vector128<Single>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse/CompareNotEqual.Single.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse/CompareNotEqual.Single.cs
index a844414c385c..c7d88cff3eb6 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Sse/CompareNotEqual.Single.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse/CompareNotEqual.Single.cs
@@ -334,7 +334,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -342,7 +342,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -374,9 +379,11 @@ private void ValidateResult(void* left, void* right, void* result, [CallerMember
 
         private void ValidateResult(Single[] left, Single[] right, Single[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (BitConverter.SingleToInt32Bits(result[0]) != ((left[0] != right[0]) ? -1 : 0))
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -384,19 +391,21 @@ private void ValidateResult(Single[] left, Single[] right, Single[] result, [Cal
                 {
                     if (BitConverter.SingleToInt32Bits(result[i]) != ((left[i] != right[i]) ? -1 : 0))
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Sse)}.{nameof(Sse.CompareNotEqual)}<Single>(Vector128<Single>, Vector128<Single>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse/CompareNotEqualOrderedScalar.Boolean.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse/CompareNotEqualOrderedScalar.Boolean.cs
index d98bf823b981..fe4b03425354 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Sse/CompareNotEqualOrderedScalar.Boolean.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse/CompareNotEqualOrderedScalar.Boolean.cs
@@ -317,7 +317,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -325,7 +325,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -355,13 +360,13 @@ private void ValidateResult(Single[] left, Single[] right, bool result, [CallerM
         {
             if ((left[0] != right[0]) != result)
             {
-                Succeeded = false;
-
                 TestLibrary.TestFramework.LogInformation($"{nameof(Sse)}.{nameof(Sse.CompareNotEqualOrderedScalar)}<Boolean>(Vector128<Single>, Vector128<Single>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse/CompareNotEqualScalar.Single.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse/CompareNotEqualScalar.Single.cs
index d750f04ad494..275b4222d6ea 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Sse/CompareNotEqualScalar.Single.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse/CompareNotEqualScalar.Single.cs
@@ -334,7 +334,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -342,7 +342,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -374,9 +379,11 @@ private void ValidateResult(void* left, void* right, void* result, [CallerMember
 
         private void ValidateResult(Single[] left, Single[] right, Single[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (BitConverter.SingleToInt32Bits(result[0]) != ((left[0] != right[0]) ? -1 : 0))
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -384,19 +391,21 @@ private void ValidateResult(Single[] left, Single[] right, Single[] result, [Cal
                 {
                     if (BitConverter.SingleToInt32Bits(left[i]) != BitConverter.SingleToInt32Bits(result[i]))
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Sse)}.{nameof(Sse.CompareNotEqualScalar)}<Single>(Vector128<Single>, Vector128<Single>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse/CompareNotEqualUnorderedScalar.Boolean.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse/CompareNotEqualUnorderedScalar.Boolean.cs
index 22fd0e347480..06995a1f510b 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Sse/CompareNotEqualUnorderedScalar.Boolean.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse/CompareNotEqualUnorderedScalar.Boolean.cs
@@ -317,7 +317,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -325,7 +325,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -355,13 +360,13 @@ private void ValidateResult(Single[] left, Single[] right, bool result, [CallerM
         {
             if ((left[0] != right[0]) != result)
             {
-                Succeeded = false;
-
                 TestLibrary.TestFramework.LogInformation($"{nameof(Sse)}.{nameof(Sse.CompareNotEqualUnorderedScalar)}<Boolean>(Vector128<Single>, Vector128<Single>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse/CompareNotGreaterThan.Single.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse/CompareNotGreaterThan.Single.cs
index 36a913d3d1a5..ca1ce83fdf0a 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Sse/CompareNotGreaterThan.Single.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse/CompareNotGreaterThan.Single.cs
@@ -334,7 +334,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -342,7 +342,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -374,9 +379,11 @@ private void ValidateResult(void* left, void* right, void* result, [CallerMember
 
         private void ValidateResult(Single[] left, Single[] right, Single[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (BitConverter.SingleToInt32Bits(result[0]) != (!(left[0] > right[0]) ? -1 : 0))
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -384,19 +391,21 @@ private void ValidateResult(Single[] left, Single[] right, Single[] result, [Cal
                 {
                     if (BitConverter.SingleToInt32Bits(result[i]) != (!(left[i] > right[i]) ? -1 : 0))
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Sse)}.{nameof(Sse.CompareNotGreaterThan)}<Single>(Vector128<Single>, Vector128<Single>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse/CompareNotGreaterThanOrEqual.Single.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse/CompareNotGreaterThanOrEqual.Single.cs
index dc33a3f64580..f4cfb49bfc29 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Sse/CompareNotGreaterThanOrEqual.Single.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse/CompareNotGreaterThanOrEqual.Single.cs
@@ -334,7 +334,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -342,7 +342,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -374,9 +379,11 @@ private void ValidateResult(void* left, void* right, void* result, [CallerMember
 
         private void ValidateResult(Single[] left, Single[] right, Single[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (BitConverter.SingleToInt32Bits(result[0]) != (!(left[0] >= right[0]) ? -1 : 0))
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -384,19 +391,21 @@ private void ValidateResult(Single[] left, Single[] right, Single[] result, [Cal
                 {
                     if (BitConverter.SingleToInt32Bits(result[i]) != (!(left[i] >= right[i]) ? -1 : 0))
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Sse)}.{nameof(Sse.CompareNotGreaterThanOrEqual)}<Single>(Vector128<Single>, Vector128<Single>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse/CompareNotGreaterThanOrEqualScalar.Single.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse/CompareNotGreaterThanOrEqualScalar.Single.cs
index 84353311b2fd..09fb86aba7fd 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Sse/CompareNotGreaterThanOrEqualScalar.Single.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse/CompareNotGreaterThanOrEqualScalar.Single.cs
@@ -334,7 +334,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -342,7 +342,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -374,9 +379,11 @@ private void ValidateResult(void* left, void* right, void* result, [CallerMember
 
         private void ValidateResult(Single[] left, Single[] right, Single[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (BitConverter.SingleToInt32Bits(result[0]) != (!(left[0] >= right[0]) ? -1 : 0))
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -384,19 +391,21 @@ private void ValidateResult(Single[] left, Single[] right, Single[] result, [Cal
                 {
                     if (BitConverter.SingleToInt32Bits(left[i]) != BitConverter.SingleToInt32Bits(result[i]))
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Sse)}.{nameof(Sse.CompareNotGreaterThanOrEqualScalar)}<Single>(Vector128<Single>, Vector128<Single>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse/CompareNotGreaterThanScalar.Single.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse/CompareNotGreaterThanScalar.Single.cs
index c2fe47d0d358..0f4c7e094bc3 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Sse/CompareNotGreaterThanScalar.Single.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse/CompareNotGreaterThanScalar.Single.cs
@@ -334,7 +334,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -342,7 +342,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -374,9 +379,11 @@ private void ValidateResult(void* left, void* right, void* result, [CallerMember
 
         private void ValidateResult(Single[] left, Single[] right, Single[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (BitConverter.SingleToInt32Bits(result[0]) != (!(left[0] > right[0]) ? -1 : 0))
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -384,19 +391,21 @@ private void ValidateResult(Single[] left, Single[] right, Single[] result, [Cal
                 {
                     if (BitConverter.SingleToInt32Bits(left[i]) != BitConverter.SingleToInt32Bits(result[i]))
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Sse)}.{nameof(Sse.CompareNotGreaterThanScalar)}<Single>(Vector128<Single>, Vector128<Single>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse/CompareNotLessThan.Single.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse/CompareNotLessThan.Single.cs
index 69908e7c3baa..9e587ac8a401 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Sse/CompareNotLessThan.Single.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse/CompareNotLessThan.Single.cs
@@ -334,7 +334,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -342,7 +342,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -374,9 +379,11 @@ private void ValidateResult(void* left, void* right, void* result, [CallerMember
 
         private void ValidateResult(Single[] left, Single[] right, Single[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (BitConverter.SingleToInt32Bits(result[0]) != (!(left[0] < right[0]) ? -1 : 0))
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -384,19 +391,21 @@ private void ValidateResult(Single[] left, Single[] right, Single[] result, [Cal
                 {
                     if (BitConverter.SingleToInt32Bits(result[i]) != (!(left[i] < right[i]) ? -1 : 0))
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Sse)}.{nameof(Sse.CompareNotLessThan)}<Single>(Vector128<Single>, Vector128<Single>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse/CompareNotLessThanOrEqual.Single.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse/CompareNotLessThanOrEqual.Single.cs
index d9ef1f61acd3..454066ec6a26 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Sse/CompareNotLessThanOrEqual.Single.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse/CompareNotLessThanOrEqual.Single.cs
@@ -334,7 +334,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -342,7 +342,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -374,9 +379,11 @@ private void ValidateResult(void* left, void* right, void* result, [CallerMember
 
         private void ValidateResult(Single[] left, Single[] right, Single[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (BitConverter.SingleToInt32Bits(result[0]) != (!(left[0] <= right[0]) ? -1 : 0))
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -384,19 +391,21 @@ private void ValidateResult(Single[] left, Single[] right, Single[] result, [Cal
                 {
                     if (BitConverter.SingleToInt32Bits(result[i]) != (!(left[i] <= right[i]) ? -1 : 0))
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Sse)}.{nameof(Sse.CompareNotLessThanOrEqual)}<Single>(Vector128<Single>, Vector128<Single>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse/CompareNotLessThanOrEqualScalar.Single.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse/CompareNotLessThanOrEqualScalar.Single.cs
index ad21caffcde0..ccdd9a9372b3 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Sse/CompareNotLessThanOrEqualScalar.Single.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse/CompareNotLessThanOrEqualScalar.Single.cs
@@ -334,7 +334,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -342,7 +342,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -374,9 +379,11 @@ private void ValidateResult(void* left, void* right, void* result, [CallerMember
 
         private void ValidateResult(Single[] left, Single[] right, Single[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (BitConverter.SingleToInt32Bits(result[0]) != (!(left[0] <= right[0]) ? -1 : 0))
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -384,19 +391,21 @@ private void ValidateResult(Single[] left, Single[] right, Single[] result, [Cal
                 {
                     if (BitConverter.SingleToInt32Bits(left[i]) != BitConverter.SingleToInt32Bits(result[i]))
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Sse)}.{nameof(Sse.CompareNotLessThanOrEqualScalar)}<Single>(Vector128<Single>, Vector128<Single>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse/CompareNotLessThanScalar.Single.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse/CompareNotLessThanScalar.Single.cs
index 22f62636f5c3..96ede7e78590 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Sse/CompareNotLessThanScalar.Single.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse/CompareNotLessThanScalar.Single.cs
@@ -334,7 +334,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -342,7 +342,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -374,9 +379,11 @@ private void ValidateResult(void* left, void* right, void* result, [CallerMember
 
         private void ValidateResult(Single[] left, Single[] right, Single[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (BitConverter.SingleToInt32Bits(result[0]) != (!(left[0] < right[0]) ? -1 : 0))
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -384,19 +391,21 @@ private void ValidateResult(Single[] left, Single[] right, Single[] result, [Cal
                 {
                     if (BitConverter.SingleToInt32Bits(left[i]) != BitConverter.SingleToInt32Bits(result[i]))
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Sse)}.{nameof(Sse.CompareNotLessThanScalar)}<Single>(Vector128<Single>, Vector128<Single>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse/CompareOrdered.Single.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse/CompareOrdered.Single.cs
index f280d6c65306..83fd0206d285 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Sse/CompareOrdered.Single.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse/CompareOrdered.Single.cs
@@ -334,7 +334,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -342,7 +342,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -374,9 +379,11 @@ private void ValidateResult(void* left, void* right, void* result, [CallerMember
 
         private void ValidateResult(Single[] left, Single[] right, Single[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (BitConverter.SingleToInt32Bits(result[0]) != ((!float.IsNaN(left[0]) && !float.IsNaN(right[0])) ? -1 : 0))
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -384,19 +391,21 @@ private void ValidateResult(Single[] left, Single[] right, Single[] result, [Cal
                 {
                     if (BitConverter.SingleToInt32Bits(result[i]) != ((!float.IsNaN(left[i]) && !float.IsNaN(right[i])) ? -1 : 0))
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Sse)}.{nameof(Sse.CompareOrdered)}<Single>(Vector128<Single>, Vector128<Single>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse/CompareOrderedScalar.Single.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse/CompareOrderedScalar.Single.cs
index cb66abcc15e3..98834f6293cb 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Sse/CompareOrderedScalar.Single.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse/CompareOrderedScalar.Single.cs
@@ -334,7 +334,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -342,7 +342,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -374,9 +379,11 @@ private void ValidateResult(void* left, void* right, void* result, [CallerMember
 
         private void ValidateResult(Single[] left, Single[] right, Single[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (BitConverter.SingleToInt32Bits(result[0]) != ((!float.IsNaN(left[0]) && !float.IsNaN(right[0])) ? -1 : 0))
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -384,19 +391,21 @@ private void ValidateResult(Single[] left, Single[] right, Single[] result, [Cal
                 {
                     if (BitConverter.SingleToInt32Bits(left[i]) != BitConverter.SingleToInt32Bits(result[i]))
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Sse)}.{nameof(Sse.CompareOrderedScalar)}<Single>(Vector128<Single>, Vector128<Single>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse/CompareUnordered.Single.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse/CompareUnordered.Single.cs
index 489e81403982..34e4175d6eae 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Sse/CompareUnordered.Single.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse/CompareUnordered.Single.cs
@@ -334,7 +334,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -342,7 +342,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -374,9 +379,11 @@ private void ValidateResult(void* left, void* right, void* result, [CallerMember
 
         private void ValidateResult(Single[] left, Single[] right, Single[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (BitConverter.SingleToInt32Bits(result[0]) != ((float.IsNaN(left[0]) || float.IsNaN(right[0])) ? -1 : 0))
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -384,19 +391,21 @@ private void ValidateResult(Single[] left, Single[] right, Single[] result, [Cal
                 {
                     if (BitConverter.SingleToInt32Bits(result[i]) != ((float.IsNaN(left[i]) || float.IsNaN(right[i])) ? -1 : 0))
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Sse)}.{nameof(Sse.CompareUnordered)}<Single>(Vector128<Single>, Vector128<Single>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse/CompareUnorderedScalar.Single.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse/CompareUnorderedScalar.Single.cs
index bb09a2237ebb..63c152df5800 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Sse/CompareUnorderedScalar.Single.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse/CompareUnorderedScalar.Single.cs
@@ -334,7 +334,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -342,7 +342,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -374,9 +379,11 @@ private void ValidateResult(void* left, void* right, void* result, [CallerMember
 
         private void ValidateResult(Single[] left, Single[] right, Single[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (BitConverter.SingleToInt32Bits(result[0]) != ((float.IsNaN(left[0]) || float.IsNaN(right[0])) ? -1 : 0))
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -384,19 +391,21 @@ private void ValidateResult(Single[] left, Single[] right, Single[] result, [Cal
                 {
                     if (BitConverter.SingleToInt32Bits(left[i]) != BitConverter.SingleToInt32Bits(result[i]))
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Sse)}.{nameof(Sse.CompareUnorderedScalar)}<Single>(Vector128<Single>, Vector128<Single>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse/Divide.Single.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse/Divide.Single.cs
index 0082ac1d3b15..f22df34dc040 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Sse/Divide.Single.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse/Divide.Single.cs
@@ -334,7 +334,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -342,7 +342,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -374,9 +379,11 @@ private void ValidateResult(void* left, void* right, void* result, [CallerMember
 
         private void ValidateResult(Single[] left, Single[] right, Single[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (BitConverter.SingleToInt32Bits(left[0] / right[0]) != BitConverter.SingleToInt32Bits(result[0]))
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -384,19 +391,21 @@ private void ValidateResult(Single[] left, Single[] right, Single[] result, [Cal
                 {
                     if (BitConverter.SingleToInt32Bits(left[i] / right[i]) != BitConverter.SingleToInt32Bits(result[i]))
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Sse)}.{nameof(Sse.Divide)}<Single>(Vector128<Single>, Vector128<Single>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse/DivideScalar.Single.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse/DivideScalar.Single.cs
index 17c55b10929a..90a40cecb0af 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Sse/DivideScalar.Single.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse/DivideScalar.Single.cs
@@ -334,7 +334,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -342,7 +342,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -374,9 +379,11 @@ private void ValidateResult(void* left, void* right, void* result, [CallerMember
 
         private void ValidateResult(Single[] left, Single[] right, Single[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (BitConverter.SingleToInt32Bits(left[0] / right[0]) != BitConverter.SingleToInt32Bits(result[0]))
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -384,19 +391,21 @@ private void ValidateResult(Single[] left, Single[] right, Single[] result, [Cal
                 {
                     if (BitConverter.SingleToInt32Bits(left[i]) != BitConverter.SingleToInt32Bits(result[i]))
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Sse)}.{nameof(Sse.DivideScalar)}<Single>(Vector128<Single>, Vector128<Single>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse/LoadScalarVector128.Single.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse/LoadScalarVector128.Single.cs
index 20ac28be21dd..15017a7228e2 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Sse/LoadScalarVector128.Single.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse/LoadScalarVector128.Single.cs
@@ -133,9 +133,11 @@ private void ValidateResult(void* firstOp, void* result, [CallerMemberName] stri
 
         private void ValidateResult(Single[] firstOp, Single[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (BitConverter.SingleToInt32Bits(firstOp[0]) != BitConverter.SingleToInt32Bits(result[0]))
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -143,18 +145,20 @@ private void ValidateResult(Single[] firstOp, Single[] result, [CallerMemberName
                 {
                     if (0 != BitConverter.SingleToInt32Bits(result[i]))
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Sse)}.{nameof(Sse.LoadScalarVector128)}<Single>(Vector128<Single>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"  firstOp: ({string.Join(", ", firstOp)})");
                 TestLibrary.TestFramework.LogInformation($"   result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse/LoadVector128.Single.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse/LoadVector128.Single.cs
index fce4c4a7460d..dee05e6ae533 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Sse/LoadVector128.Single.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse/LoadVector128.Single.cs
@@ -133,9 +133,11 @@ private void ValidateResult(void* firstOp, void* result, [CallerMemberName] stri
 
         private void ValidateResult(Single[] firstOp, Single[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (BitConverter.SingleToInt32Bits(firstOp[0]) != BitConverter.SingleToInt32Bits(result[0]))
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -143,18 +145,20 @@ private void ValidateResult(Single[] firstOp, Single[] result, [CallerMemberName
                 {
                     if (BitConverter.SingleToInt32Bits(firstOp[i]) != BitConverter.SingleToInt32Bits(result[i]))
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Sse)}.{nameof(Sse.LoadVector128)}<Single>(Vector128<Single>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"  firstOp: ({string.Join(", ", firstOp)})");
                 TestLibrary.TestFramework.LogInformation($"   result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse/Max.Single.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse/Max.Single.cs
index e0c5cf51a300..b8287c0aa8ce 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Sse/Max.Single.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse/Max.Single.cs
@@ -334,7 +334,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -342,7 +342,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -374,9 +379,11 @@ private void ValidateResult(void* left, void* right, void* result, [CallerMember
 
         private void ValidateResult(Single[] left, Single[] right, Single[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (BitConverter.SingleToInt32Bits(Math.Max(left[0], right[0])) != BitConverter.SingleToInt32Bits(result[0]))
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -384,19 +391,21 @@ private void ValidateResult(Single[] left, Single[] right, Single[] result, [Cal
                 {
                     if (BitConverter.SingleToInt32Bits(Math.Max(left[i], right[i])) != BitConverter.SingleToInt32Bits(result[i]))
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Sse)}.{nameof(Sse.Max)}<Single>(Vector128<Single>, Vector128<Single>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse/MaxScalar.Single.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse/MaxScalar.Single.cs
index 308199cb263f..ff0c462500ef 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Sse/MaxScalar.Single.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse/MaxScalar.Single.cs
@@ -334,7 +334,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -342,7 +342,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -374,9 +379,11 @@ private void ValidateResult(void* left, void* right, void* result, [CallerMember
 
         private void ValidateResult(Single[] left, Single[] right, Single[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (BitConverter.SingleToInt32Bits(Math.Max(left[0], right[0])) != BitConverter.SingleToInt32Bits(result[0]))
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -384,19 +391,21 @@ private void ValidateResult(Single[] left, Single[] right, Single[] result, [Cal
                 {
                     if (BitConverter.SingleToInt32Bits(left[i]) != BitConverter.SingleToInt32Bits(result[i]))
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Sse)}.{nameof(Sse.MaxScalar)}<Single>(Vector128<Single>, Vector128<Single>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse/Min.Single.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse/Min.Single.cs
index e345a29ec9d8..4de668d0bf0d 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Sse/Min.Single.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse/Min.Single.cs
@@ -334,7 +334,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -342,7 +342,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -374,9 +379,11 @@ private void ValidateResult(void* left, void* right, void* result, [CallerMember
 
         private void ValidateResult(Single[] left, Single[] right, Single[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (BitConverter.SingleToInt32Bits(Math.Min(left[0], right[0])) != BitConverter.SingleToInt32Bits(result[0]))
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -384,19 +391,21 @@ private void ValidateResult(Single[] left, Single[] right, Single[] result, [Cal
                 {
                     if (BitConverter.SingleToInt32Bits(Math.Min(left[i], right[i])) != BitConverter.SingleToInt32Bits(result[i]))
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Sse)}.{nameof(Sse.Min)}<Single>(Vector128<Single>, Vector128<Single>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse/MinScalar.Single.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse/MinScalar.Single.cs
index ca351f705252..b1a0f2115f30 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Sse/MinScalar.Single.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse/MinScalar.Single.cs
@@ -334,7 +334,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -342,7 +342,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -374,9 +379,11 @@ private void ValidateResult(void* left, void* right, void* result, [CallerMember
 
         private void ValidateResult(Single[] left, Single[] right, Single[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (BitConverter.SingleToInt32Bits(Math.Min(left[0], right[0])) != BitConverter.SingleToInt32Bits(result[0]))
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -384,19 +391,21 @@ private void ValidateResult(Single[] left, Single[] right, Single[] result, [Cal
                 {
                     if (BitConverter.SingleToInt32Bits(left[i]) != BitConverter.SingleToInt32Bits(result[i]))
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Sse)}.{nameof(Sse.MinScalar)}<Single>(Vector128<Single>, Vector128<Single>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse/Multiply.Single.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse/Multiply.Single.cs
index b683d0f4303f..80cd04f232ae 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Sse/Multiply.Single.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse/Multiply.Single.cs
@@ -334,7 +334,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -342,7 +342,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -374,9 +379,11 @@ private void ValidateResult(void* left, void* right, void* result, [CallerMember
 
         private void ValidateResult(Single[] left, Single[] right, Single[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (BitConverter.SingleToInt32Bits(left[0] * right[0]) != BitConverter.SingleToInt32Bits(result[0]))
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -384,19 +391,21 @@ private void ValidateResult(Single[] left, Single[] right, Single[] result, [Cal
                 {
                     if (BitConverter.SingleToInt32Bits(left[i] * right[i]) != BitConverter.SingleToInt32Bits(result[i]))
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Sse)}.{nameof(Sse.Multiply)}<Single>(Vector128<Single>, Vector128<Single>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse/MultiplyScalar.Single.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse/MultiplyScalar.Single.cs
index 8f08242c23b6..2750cc7f33c3 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Sse/MultiplyScalar.Single.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse/MultiplyScalar.Single.cs
@@ -334,7 +334,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -342,7 +342,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -374,9 +379,11 @@ private void ValidateResult(void* left, void* right, void* result, [CallerMember
 
         private void ValidateResult(Single[] left, Single[] right, Single[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (BitConverter.SingleToInt32Bits(left[0] * right[0]) != BitConverter.SingleToInt32Bits(result[0]))
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -384,19 +391,21 @@ private void ValidateResult(Single[] left, Single[] right, Single[] result, [Cal
                 {
                     if (BitConverter.SingleToInt32Bits(left[i]) != BitConverter.SingleToInt32Bits(result[i]))
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Sse)}.{nameof(Sse.MultiplyScalar)}<Single>(Vector128<Single>, Vector128<Single>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse/Or.Single.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse/Or.Single.cs
index fa6694a8ef18..be994428781b 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Sse/Or.Single.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse/Or.Single.cs
@@ -334,7 +334,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -342,7 +342,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -374,9 +379,11 @@ private void ValidateResult(void* left, void* right, void* result, [CallerMember
 
         private void ValidateResult(Single[] left, Single[] right, Single[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if ((BitConverter.SingleToInt32Bits(left[0]) | BitConverter.SingleToInt32Bits(right[0])) != BitConverter.SingleToInt32Bits(result[0]))
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -384,19 +391,21 @@ private void ValidateResult(Single[] left, Single[] right, Single[] result, [Cal
                 {
                     if ((BitConverter.SingleToInt32Bits(left[0]) | BitConverter.SingleToInt32Bits(right[0])) != BitConverter.SingleToInt32Bits(result[0]))
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Sse)}.{nameof(Sse.Or)}<Single>(Vector128<Single>, Vector128<Single>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse/Subtract.Single.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse/Subtract.Single.cs
index 5c3f62321c56..09c142ff7207 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Sse/Subtract.Single.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse/Subtract.Single.cs
@@ -334,7 +334,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -342,7 +342,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -374,9 +379,11 @@ private void ValidateResult(void* left, void* right, void* result, [CallerMember
 
         private void ValidateResult(Single[] left, Single[] right, Single[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (BitConverter.SingleToInt32Bits(left[0] - right[0]) != BitConverter.SingleToInt32Bits(result[0]))
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -384,19 +391,21 @@ private void ValidateResult(Single[] left, Single[] right, Single[] result, [Cal
                 {
                     if (BitConverter.SingleToInt32Bits(left[i] - right[i]) != BitConverter.SingleToInt32Bits(result[i]))
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Sse)}.{nameof(Sse.Subtract)}<Single>(Vector128<Single>, Vector128<Single>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse/SubtractScalar.Single.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse/SubtractScalar.Single.cs
index 48252428231c..9f864ec1bba4 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Sse/SubtractScalar.Single.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse/SubtractScalar.Single.cs
@@ -334,7 +334,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -342,7 +342,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -374,9 +379,11 @@ private void ValidateResult(void* left, void* right, void* result, [CallerMember
 
         private void ValidateResult(Single[] left, Single[] right, Single[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (BitConverter.SingleToInt32Bits(left[0] - right[0]) != BitConverter.SingleToInt32Bits(result[0]))
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -384,19 +391,21 @@ private void ValidateResult(Single[] left, Single[] right, Single[] result, [Cal
                 {
                     if (BitConverter.SingleToInt32Bits(left[i]) != BitConverter.SingleToInt32Bits(result[i]))
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Sse)}.{nameof(Sse.SubtractScalar)}<Single>(Vector128<Single>, Vector128<Single>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse/Xor.Single.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse/Xor.Single.cs
index edc9c3d6970d..2d45e4289bdf 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Sse/Xor.Single.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse/Xor.Single.cs
@@ -334,7 +334,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -342,7 +342,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -374,9 +379,11 @@ private void ValidateResult(void* left, void* right, void* result, [CallerMember
 
         private void ValidateResult(Single[] left, Single[] right, Single[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if ((BitConverter.SingleToInt32Bits(left[0]) ^ BitConverter.SingleToInt32Bits(right[0])) != BitConverter.SingleToInt32Bits(result[0]))
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -384,19 +391,21 @@ private void ValidateResult(Single[] left, Single[] right, Single[] result, [Cal
                 {
                     if ((BitConverter.SingleToInt32Bits(left[0]) ^ BitConverter.SingleToInt32Bits(right[0])) != BitConverter.SingleToInt32Bits(result[0]))
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Sse)}.{nameof(Sse.Xor)}<Single>(Vector128<Single>, Vector128<Single>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/Add.Byte.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/Add.Byte.cs
index 3c295d896201..c98c049563ec 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/Add.Byte.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/Add.Byte.cs
@@ -334,7 +334,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -342,7 +342,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -374,9 +379,11 @@ private void ValidateResult(void* left, void* right, void* result, [CallerMember
 
         private void ValidateResult(Byte[] left, Byte[] right, Byte[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if ((byte)(left[0] + right[0]) != result[0])
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -384,19 +391,21 @@ private void ValidateResult(Byte[] left, Byte[] right, Byte[] result, [CallerMem
                 {
                     if ((byte)(left[i] + right[i]) != result[i])
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Sse2)}.{nameof(Sse2.Add)}<Byte>(Vector128<Byte>, Vector128<Byte>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/Add.Double.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/Add.Double.cs
index 0f9c42781dff..862e73a52199 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/Add.Double.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/Add.Double.cs
@@ -334,7 +334,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -342,7 +342,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -374,9 +379,11 @@ private void ValidateResult(void* left, void* right, void* result, [CallerMember
 
         private void ValidateResult(Double[] left, Double[] right, Double[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (BitConverter.DoubleToInt64Bits(left[0] + right[0]) != BitConverter.DoubleToInt64Bits(result[0]))
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -384,19 +391,21 @@ private void ValidateResult(Double[] left, Double[] right, Double[] result, [Cal
                 {
                     if (BitConverter.DoubleToInt64Bits(left[i] + right[i]) != BitConverter.DoubleToInt64Bits(result[i]))
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Sse2)}.{nameof(Sse2.Add)}<Double>(Vector128<Double>, Vector128<Double>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/Add.Int16.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/Add.Int16.cs
index 9014ce29cb1b..f7eeaaebd40f 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/Add.Int16.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/Add.Int16.cs
@@ -334,7 +334,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -342,7 +342,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -374,9 +379,11 @@ private void ValidateResult(void* left, void* right, void* result, [CallerMember
 
         private void ValidateResult(Int16[] left, Int16[] right, Int16[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if ((short)(left[0] + right[0]) != result[0])
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -384,19 +391,21 @@ private void ValidateResult(Int16[] left, Int16[] right, Int16[] result, [Caller
                 {
                     if ((short)(left[i] + right[i]) != result[i])
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Sse2)}.{nameof(Sse2.Add)}<Int16>(Vector128<Int16>, Vector128<Int16>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/Add.Int32.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/Add.Int32.cs
index db6500b2dacc..ebffdc77d2fc 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/Add.Int32.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/Add.Int32.cs
@@ -334,7 +334,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -342,7 +342,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -374,9 +379,11 @@ private void ValidateResult(void* left, void* right, void* result, [CallerMember
 
         private void ValidateResult(Int32[] left, Int32[] right, Int32[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if ((int)(left[0] + right[0]) != result[0])
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -384,19 +391,21 @@ private void ValidateResult(Int32[] left, Int32[] right, Int32[] result, [Caller
                 {
                     if ((int)(left[i] + right[i]) != result[i])
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Sse2)}.{nameof(Sse2.Add)}<Int32>(Vector128<Int32>, Vector128<Int32>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/Add.Int64.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/Add.Int64.cs
index 5b370e6de121..5c2470825d1f 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/Add.Int64.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/Add.Int64.cs
@@ -334,7 +334,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -342,7 +342,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -374,9 +379,11 @@ private void ValidateResult(void* left, void* right, void* result, [CallerMember
 
         private void ValidateResult(Int64[] left, Int64[] right, Int64[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if ((long)(left[0] + right[0]) != result[0])
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -384,19 +391,21 @@ private void ValidateResult(Int64[] left, Int64[] right, Int64[] result, [Caller
                 {
                     if ((long)(left[i] + right[i]) != result[i])
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Sse2)}.{nameof(Sse2.Add)}<Int64>(Vector128<Int64>, Vector128<Int64>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/Add.SByte.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/Add.SByte.cs
index 987b7f05cdb9..97548c69546d 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/Add.SByte.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/Add.SByte.cs
@@ -334,7 +334,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -342,7 +342,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -374,9 +379,11 @@ private void ValidateResult(void* left, void* right, void* result, [CallerMember
 
         private void ValidateResult(SByte[] left, SByte[] right, SByte[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if ((sbyte)(left[0] + right[0]) != result[0])
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -384,19 +391,21 @@ private void ValidateResult(SByte[] left, SByte[] right, SByte[] result, [Caller
                 {
                     if ((sbyte)(left[i] + right[i]) != result[i])
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Sse2)}.{nameof(Sse2.Add)}<SByte>(Vector128<SByte>, Vector128<SByte>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/Add.UInt16.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/Add.UInt16.cs
index 7f71efbf0810..c534c72ccc53 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/Add.UInt16.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/Add.UInt16.cs
@@ -334,7 +334,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -342,7 +342,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -374,9 +379,11 @@ private void ValidateResult(void* left, void* right, void* result, [CallerMember
 
         private void ValidateResult(UInt16[] left, UInt16[] right, UInt16[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if ((ushort)(left[0] + right[0]) != result[0])
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -384,19 +391,21 @@ private void ValidateResult(UInt16[] left, UInt16[] right, UInt16[] result, [Cal
                 {
                     if ((ushort)(left[i] + right[i]) != result[i])
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Sse2)}.{nameof(Sse2.Add)}<UInt16>(Vector128<UInt16>, Vector128<UInt16>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/Add.UInt32.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/Add.UInt32.cs
index c2b3aacf6d75..aa2962036a33 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/Add.UInt32.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/Add.UInt32.cs
@@ -334,7 +334,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -342,7 +342,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -374,9 +379,11 @@ private void ValidateResult(void* left, void* right, void* result, [CallerMember
 
         private void ValidateResult(UInt32[] left, UInt32[] right, UInt32[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if ((uint)(left[0] + right[0]) != result[0])
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -384,19 +391,21 @@ private void ValidateResult(UInt32[] left, UInt32[] right, UInt32[] result, [Cal
                 {
                     if ((uint)(left[i] + right[i]) != result[i])
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Sse2)}.{nameof(Sse2.Add)}<UInt32>(Vector128<UInt32>, Vector128<UInt32>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/Add.UInt64.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/Add.UInt64.cs
index 4e1425aa6878..c967252bfc8b 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/Add.UInt64.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/Add.UInt64.cs
@@ -334,7 +334,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -342,7 +342,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -374,9 +379,11 @@ private void ValidateResult(void* left, void* right, void* result, [CallerMember
 
         private void ValidateResult(UInt64[] left, UInt64[] right, UInt64[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if ((ulong)(left[0] + right[0]) != result[0])
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -384,19 +391,21 @@ private void ValidateResult(UInt64[] left, UInt64[] right, UInt64[] result, [Cal
                 {
                     if ((ulong)(left[i] + right[i]) != result[i])
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Sse2)}.{nameof(Sse2.Add)}<UInt64>(Vector128<UInt64>, Vector128<UInt64>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/AddSaturate.Byte.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/AddSaturate.Byte.cs
index 5a141b7fd1e6..ce003314f0c6 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/AddSaturate.Byte.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/AddSaturate.Byte.cs
@@ -334,7 +334,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -342,7 +342,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -374,9 +379,11 @@ private void ValidateResult(void* left, void* right, void* result, [CallerMember
 
         private void ValidateResult(Byte[] left, Byte[] right, Byte[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (Sse2Verify.AddSaturate(left[0], right[0], result[0]))
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -384,19 +391,21 @@ private void ValidateResult(Byte[] left, Byte[] right, Byte[] result, [CallerMem
                 {
                     if (Sse2Verify.AddSaturate(left[i], right[i], result[i]))
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Sse2)}.{nameof(Sse2.AddSaturate)}<Byte>(Vector128<Byte>, Vector128<Byte>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/AddSaturate.Int16.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/AddSaturate.Int16.cs
index c6344ab9dc52..d410f797d4ac 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/AddSaturate.Int16.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/AddSaturate.Int16.cs
@@ -334,7 +334,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -342,7 +342,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -374,9 +379,11 @@ private void ValidateResult(void* left, void* right, void* result, [CallerMember
 
         private void ValidateResult(Int16[] left, Int16[] right, Int16[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (Sse2Verify.AddSaturate(left[0], right[0], result[0]))
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -384,19 +391,21 @@ private void ValidateResult(Int16[] left, Int16[] right, Int16[] result, [Caller
                 {
                     if (Sse2Verify.AddSaturate(left[i], right[i], result[i]))
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Sse2)}.{nameof(Sse2.AddSaturate)}<Int16>(Vector128<Int16>, Vector128<Int16>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/AddSaturate.SByte.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/AddSaturate.SByte.cs
index 2e0a9fc1f6dc..122a28acff1b 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/AddSaturate.SByte.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/AddSaturate.SByte.cs
@@ -334,7 +334,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -342,7 +342,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -374,9 +379,11 @@ private void ValidateResult(void* left, void* right, void* result, [CallerMember
 
         private void ValidateResult(SByte[] left, SByte[] right, SByte[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (Sse2Verify.AddSaturate(left[0], right[0], result[0]))
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -384,19 +391,21 @@ private void ValidateResult(SByte[] left, SByte[] right, SByte[] result, [Caller
                 {
                     if (Sse2Verify.AddSaturate(left[i], right[i], result[i]))
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Sse2)}.{nameof(Sse2.AddSaturate)}<SByte>(Vector128<SByte>, Vector128<SByte>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/AddSaturate.UInt16.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/AddSaturate.UInt16.cs
index 720ea465db1a..4a720acae7d7 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/AddSaturate.UInt16.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/AddSaturate.UInt16.cs
@@ -334,7 +334,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -342,7 +342,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -374,9 +379,11 @@ private void ValidateResult(void* left, void* right, void* result, [CallerMember
 
         private void ValidateResult(UInt16[] left, UInt16[] right, UInt16[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (Sse2Verify.AddSaturate(left[0], right[0], result[0]))
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -384,19 +391,21 @@ private void ValidateResult(UInt16[] left, UInt16[] right, UInt16[] result, [Cal
                 {
                     if (Sse2Verify.AddSaturate(left[i], right[i], result[i]))
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Sse2)}.{nameof(Sse2.AddSaturate)}<UInt16>(Vector128<UInt16>, Vector128<UInt16>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/AddScalar.Double.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/AddScalar.Double.cs
index da3fe49b08ff..f4fccc911f0c 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/AddScalar.Double.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/AddScalar.Double.cs
@@ -334,7 +334,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -342,7 +342,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -374,9 +379,11 @@ private void ValidateResult(void* left, void* right, void* result, [CallerMember
 
         private void ValidateResult(Double[] left, Double[] right, Double[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (BitConverter.DoubleToInt64Bits(left[0] + right[0]) != BitConverter.DoubleToInt64Bits(result[0]))
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -384,19 +391,21 @@ private void ValidateResult(Double[] left, Double[] right, Double[] result, [Cal
                 {
                     if (BitConverter.DoubleToInt64Bits(left[i]) != BitConverter.DoubleToInt64Bits(result[i]))
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Sse2)}.{nameof(Sse2.AddScalar)}<Double>(Vector128<Double>, Vector128<Double>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/And.Byte.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/And.Byte.cs
index 16137651f8f4..635b49656bd3 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/And.Byte.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/And.Byte.cs
@@ -334,7 +334,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -342,7 +342,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -374,9 +379,11 @@ private void ValidateResult(void* left, void* right, void* result, [CallerMember
 
         private void ValidateResult(Byte[] left, Byte[] right, Byte[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if ((byte)(left[0] & right[0]) != result[0])
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -384,19 +391,21 @@ private void ValidateResult(Byte[] left, Byte[] right, Byte[] result, [CallerMem
                 {
                     if ((byte)(left[i] & right[i]) != result[i])
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Sse2)}.{nameof(Sse2.And)}<Byte>(Vector128<Byte>, Vector128<Byte>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/And.Double.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/And.Double.cs
index 5a4581e1f77e..10e8544b9dc0 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/And.Double.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/And.Double.cs
@@ -334,7 +334,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -342,7 +342,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -374,9 +379,11 @@ private void ValidateResult(void* left, void* right, void* result, [CallerMember
 
         private void ValidateResult(Double[] left, Double[] right, Double[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if ((BitConverter.DoubleToInt64Bits(left[0]) & BitConverter.DoubleToInt64Bits(right[0])) != BitConverter.DoubleToInt64Bits(result[0]))
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -384,19 +391,21 @@ private void ValidateResult(Double[] left, Double[] right, Double[] result, [Cal
                 {
                     if ((BitConverter.DoubleToInt64Bits(left[i]) & BitConverter.DoubleToInt64Bits(right[i])) != BitConverter.DoubleToInt64Bits(result[i]))
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Sse2)}.{nameof(Sse2.And)}<Double>(Vector128<Double>, Vector128<Double>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/And.Int16.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/And.Int16.cs
index 6ead6c74b831..c3bd4436b06c 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/And.Int16.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/And.Int16.cs
@@ -334,7 +334,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -342,7 +342,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -374,9 +379,11 @@ private void ValidateResult(void* left, void* right, void* result, [CallerMember
 
         private void ValidateResult(Int16[] left, Int16[] right, Int16[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if ((short)(left[0] & right[0]) != result[0])
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -384,19 +391,21 @@ private void ValidateResult(Int16[] left, Int16[] right, Int16[] result, [Caller
                 {
                     if ((short)(left[i] & right[i]) != result[i])
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Sse2)}.{nameof(Sse2.And)}<Int16>(Vector128<Int16>, Vector128<Int16>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/And.Int32.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/And.Int32.cs
index 2817ce82b8bf..c8b7d9c4ce09 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/And.Int32.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/And.Int32.cs
@@ -334,7 +334,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -342,7 +342,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -374,9 +379,11 @@ private void ValidateResult(void* left, void* right, void* result, [CallerMember
 
         private void ValidateResult(Int32[] left, Int32[] right, Int32[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if ((int)(left[0] & right[0]) != result[0])
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -384,19 +391,21 @@ private void ValidateResult(Int32[] left, Int32[] right, Int32[] result, [Caller
                 {
                     if ((int)(left[i] & right[i]) != result[i])
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Sse2)}.{nameof(Sse2.And)}<Int32>(Vector128<Int32>, Vector128<Int32>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/And.Int64.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/And.Int64.cs
index 9186926febaf..9247fca70b78 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/And.Int64.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/And.Int64.cs
@@ -334,7 +334,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -342,7 +342,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -374,9 +379,11 @@ private void ValidateResult(void* left, void* right, void* result, [CallerMember
 
         private void ValidateResult(Int64[] left, Int64[] right, Int64[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if ((long)(left[0] & right[0]) != result[0])
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -384,19 +391,21 @@ private void ValidateResult(Int64[] left, Int64[] right, Int64[] result, [Caller
                 {
                     if ((long)(left[i] & right[i]) != result[i])
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Sse2)}.{nameof(Sse2.And)}<Int64>(Vector128<Int64>, Vector128<Int64>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/And.SByte.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/And.SByte.cs
index 4b51077cd0a2..619b8f2fb57f 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/And.SByte.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/And.SByte.cs
@@ -334,7 +334,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -342,7 +342,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -374,9 +379,11 @@ private void ValidateResult(void* left, void* right, void* result, [CallerMember
 
         private void ValidateResult(SByte[] left, SByte[] right, SByte[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if ((sbyte)(left[0] & right[0]) != result[0])
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -384,19 +391,21 @@ private void ValidateResult(SByte[] left, SByte[] right, SByte[] result, [Caller
                 {
                     if ((sbyte)(left[i] & right[i]) != result[i])
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Sse2)}.{nameof(Sse2.And)}<SByte>(Vector128<SByte>, Vector128<SByte>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/And.UInt16.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/And.UInt16.cs
index 908c90425f27..a4c3a80eca0e 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/And.UInt16.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/And.UInt16.cs
@@ -334,7 +334,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -342,7 +342,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -374,9 +379,11 @@ private void ValidateResult(void* left, void* right, void* result, [CallerMember
 
         private void ValidateResult(UInt16[] left, UInt16[] right, UInt16[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if ((ushort)(left[0] & right[0]) != result[0])
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -384,19 +391,21 @@ private void ValidateResult(UInt16[] left, UInt16[] right, UInt16[] result, [Cal
                 {
                     if ((ushort)(left[i] & right[i]) != result[i])
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Sse2)}.{nameof(Sse2.And)}<UInt16>(Vector128<UInt16>, Vector128<UInt16>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/And.UInt32.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/And.UInt32.cs
index 57c0d4ffb31a..ff59e506381d 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/And.UInt32.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/And.UInt32.cs
@@ -334,7 +334,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -342,7 +342,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -374,9 +379,11 @@ private void ValidateResult(void* left, void* right, void* result, [CallerMember
 
         private void ValidateResult(UInt32[] left, UInt32[] right, UInt32[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if ((uint)(left[0] & right[0]) != result[0])
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -384,19 +391,21 @@ private void ValidateResult(UInt32[] left, UInt32[] right, UInt32[] result, [Cal
                 {
                     if ((uint)(left[i] & right[i]) != result[i])
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Sse2)}.{nameof(Sse2.And)}<UInt32>(Vector128<UInt32>, Vector128<UInt32>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/And.UInt64.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/And.UInt64.cs
index 4f3cea4a2f8b..2691979aa7b7 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/And.UInt64.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/And.UInt64.cs
@@ -334,7 +334,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -342,7 +342,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -374,9 +379,11 @@ private void ValidateResult(void* left, void* right, void* result, [CallerMember
 
         private void ValidateResult(UInt64[] left, UInt64[] right, UInt64[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if ((ulong)(left[0] & right[0]) != result[0])
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -384,19 +391,21 @@ private void ValidateResult(UInt64[] left, UInt64[] right, UInt64[] result, [Cal
                 {
                     if ((ulong)(left[i] & right[i]) != result[i])
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Sse2)}.{nameof(Sse2.And)}<UInt64>(Vector128<UInt64>, Vector128<UInt64>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/AndNot.Byte.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/AndNot.Byte.cs
index 8444aefaeb92..c94654046fde 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/AndNot.Byte.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/AndNot.Byte.cs
@@ -334,7 +334,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -342,7 +342,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -374,9 +379,11 @@ private void ValidateResult(void* left, void* right, void* result, [CallerMember
 
         private void ValidateResult(Byte[] left, Byte[] right, Byte[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if ((byte)(~left[0] & right[0]) != result[0])
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -384,19 +391,21 @@ private void ValidateResult(Byte[] left, Byte[] right, Byte[] result, [CallerMem
                 {
                     if ((byte)(~left[i] & right[i]) != result[i])
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Sse2)}.{nameof(Sse2.AndNot)}<Byte>(Vector128<Byte>, Vector128<Byte>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/AndNot.Double.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/AndNot.Double.cs
index 2fe071b8ede9..6b0bf62d4d10 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/AndNot.Double.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/AndNot.Double.cs
@@ -334,7 +334,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -342,7 +342,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -374,9 +379,11 @@ private void ValidateResult(void* left, void* right, void* result, [CallerMember
 
         private void ValidateResult(Double[] left, Double[] right, Double[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if ((~BitConverter.DoubleToInt64Bits(left[0]) & BitConverter.DoubleToInt64Bits(right[0])) != BitConverter.DoubleToInt64Bits(result[0]))
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -384,19 +391,21 @@ private void ValidateResult(Double[] left, Double[] right, Double[] result, [Cal
                 {
                     if ((~BitConverter.DoubleToInt64Bits(left[i]) & BitConverter.DoubleToInt64Bits(right[i])) != BitConverter.DoubleToInt64Bits(result[i]))
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Sse2)}.{nameof(Sse2.AndNot)}<Double>(Vector128<Double>, Vector128<Double>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/AndNot.Int16.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/AndNot.Int16.cs
index de6c7319acfb..5923db43a569 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/AndNot.Int16.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/AndNot.Int16.cs
@@ -334,7 +334,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -342,7 +342,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -374,9 +379,11 @@ private void ValidateResult(void* left, void* right, void* result, [CallerMember
 
         private void ValidateResult(Int16[] left, Int16[] right, Int16[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if ((short)(~left[0] & right[0]) != result[0])
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -384,19 +391,21 @@ private void ValidateResult(Int16[] left, Int16[] right, Int16[] result, [Caller
                 {
                     if ((short)(~left[i] & right[i]) != result[i])
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Sse2)}.{nameof(Sse2.AndNot)}<Int16>(Vector128<Int16>, Vector128<Int16>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/AndNot.Int32.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/AndNot.Int32.cs
index 66596bffa239..c5128d4ee064 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/AndNot.Int32.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/AndNot.Int32.cs
@@ -334,7 +334,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -342,7 +342,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -374,9 +379,11 @@ private void ValidateResult(void* left, void* right, void* result, [CallerMember
 
         private void ValidateResult(Int32[] left, Int32[] right, Int32[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if ((int)(~left[0] & right[0]) != result[0])
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -384,19 +391,21 @@ private void ValidateResult(Int32[] left, Int32[] right, Int32[] result, [Caller
                 {
                     if ((int)(~left[i] & right[i]) != result[i])
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Sse2)}.{nameof(Sse2.AndNot)}<Int32>(Vector128<Int32>, Vector128<Int32>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/AndNot.Int64.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/AndNot.Int64.cs
index 8785930cd589..afa48ca06fed 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/AndNot.Int64.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/AndNot.Int64.cs
@@ -334,7 +334,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -342,7 +342,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -374,9 +379,11 @@ private void ValidateResult(void* left, void* right, void* result, [CallerMember
 
         private void ValidateResult(Int64[] left, Int64[] right, Int64[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if ((long)(~left[0] & right[0]) != result[0])
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -384,19 +391,21 @@ private void ValidateResult(Int64[] left, Int64[] right, Int64[] result, [Caller
                 {
                     if ((long)(~left[i] & right[i]) != result[i])
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Sse2)}.{nameof(Sse2.AndNot)}<Int64>(Vector128<Int64>, Vector128<Int64>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/AndNot.SByte.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/AndNot.SByte.cs
index 8eab92caa64a..6f8dbfeb8f0b 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/AndNot.SByte.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/AndNot.SByte.cs
@@ -334,7 +334,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -342,7 +342,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -374,9 +379,11 @@ private void ValidateResult(void* left, void* right, void* result, [CallerMember
 
         private void ValidateResult(SByte[] left, SByte[] right, SByte[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if ((sbyte)(~left[0] & right[0]) != result[0])
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -384,19 +391,21 @@ private void ValidateResult(SByte[] left, SByte[] right, SByte[] result, [Caller
                 {
                     if ((sbyte)(~left[i] & right[i]) != result[i])
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Sse2)}.{nameof(Sse2.AndNot)}<SByte>(Vector128<SByte>, Vector128<SByte>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/AndNot.UInt16.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/AndNot.UInt16.cs
index 24e46a47f3e5..180b90eaf655 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/AndNot.UInt16.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/AndNot.UInt16.cs
@@ -334,7 +334,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -342,7 +342,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -374,9 +379,11 @@ private void ValidateResult(void* left, void* right, void* result, [CallerMember
 
         private void ValidateResult(UInt16[] left, UInt16[] right, UInt16[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if ((ushort)(~left[0] & right[0]) != result[0])
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -384,19 +391,21 @@ private void ValidateResult(UInt16[] left, UInt16[] right, UInt16[] result, [Cal
                 {
                     if ((ushort)(~left[i] & right[i]) != result[i])
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Sse2)}.{nameof(Sse2.AndNot)}<UInt16>(Vector128<UInt16>, Vector128<UInt16>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/AndNot.UInt32.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/AndNot.UInt32.cs
index 83a5ee6b6c83..99f2ba33d2fd 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/AndNot.UInt32.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/AndNot.UInt32.cs
@@ -334,7 +334,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -342,7 +342,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -374,9 +379,11 @@ private void ValidateResult(void* left, void* right, void* result, [CallerMember
 
         private void ValidateResult(UInt32[] left, UInt32[] right, UInt32[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if ((uint)(~left[0] & right[0]) != result[0])
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -384,19 +391,21 @@ private void ValidateResult(UInt32[] left, UInt32[] right, UInt32[] result, [Cal
                 {
                     if ((uint)(~left[i] & right[i]) != result[i])
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Sse2)}.{nameof(Sse2.AndNot)}<UInt32>(Vector128<UInt32>, Vector128<UInt32>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/AndNot.UInt64.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/AndNot.UInt64.cs
index 6c3eaed6997b..5184bbdf2193 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/AndNot.UInt64.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/AndNot.UInt64.cs
@@ -334,7 +334,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -342,7 +342,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -374,9 +379,11 @@ private void ValidateResult(void* left, void* right, void* result, [CallerMember
 
         private void ValidateResult(UInt64[] left, UInt64[] right, UInt64[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if ((ulong)(~left[0] & right[0]) != result[0])
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -384,19 +391,21 @@ private void ValidateResult(UInt64[] left, UInt64[] right, UInt64[] result, [Cal
                 {
                     if ((ulong)(~left[i] & right[i]) != result[i])
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Sse2)}.{nameof(Sse2.AndNot)}<UInt64>(Vector128<UInt64>, Vector128<UInt64>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/Average.Byte.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/Average.Byte.cs
index ad2634a84e52..bddc6563cfb6 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/Average.Byte.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/Average.Byte.cs
@@ -334,7 +334,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -342,7 +342,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -374,9 +379,11 @@ private void ValidateResult(void* left, void* right, void* result, [CallerMember
 
         private void ValidateResult(Byte[] left, Byte[] right, Byte[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if ((byte)((left[0] + right[0] + 1) >> 1) != result[0])
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -384,19 +391,21 @@ private void ValidateResult(Byte[] left, Byte[] right, Byte[] result, [CallerMem
                 {
                     if ((byte)((left[i] + right[i] + 1) >> 1) != result[i])
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Sse2)}.{nameof(Sse2.Average)}<Byte>(Vector128<Byte>, Vector128<Byte>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/Average.UInt16.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/Average.UInt16.cs
index 0af90e549468..269e706e9c0f 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/Average.UInt16.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/Average.UInt16.cs
@@ -334,7 +334,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -342,7 +342,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -374,9 +379,11 @@ private void ValidateResult(void* left, void* right, void* result, [CallerMember
 
         private void ValidateResult(UInt16[] left, UInt16[] right, UInt16[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if ((ushort)((left[0] + right[0] + 1) >> 1) != result[0])
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -384,19 +391,21 @@ private void ValidateResult(UInt16[] left, UInt16[] right, UInt16[] result, [Cal
                 {
                     if ((ushort)((left[i] + right[i] + 1) >> 1) != result[i])
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Sse2)}.{nameof(Sse2.Average)}<UInt16>(Vector128<UInt16>, Vector128<UInt16>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareEqual.Byte.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareEqual.Byte.cs
index 054f42b83b82..48df1c25bb0d 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareEqual.Byte.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareEqual.Byte.cs
@@ -334,7 +334,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -342,7 +342,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -374,9 +379,11 @@ private void ValidateResult(void* left, void* right, void* result, [CallerMember
 
         private void ValidateResult(Byte[] left, Byte[] right, Byte[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (result[0] != ((left[0] == right[0]) ? unchecked((byte)(-1)) : 0))
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -384,19 +391,21 @@ private void ValidateResult(Byte[] left, Byte[] right, Byte[] result, [CallerMem
                 {
                     if (result[i] != ((left[i] == right[i]) ? unchecked((byte)(-1)) : 0))
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Sse2)}.{nameof(Sse2.CompareEqual)}<Byte>(Vector128<Byte>, Vector128<Byte>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareEqual.Double.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareEqual.Double.cs
index b2ee01b33fdb..fb32ced4af4f 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareEqual.Double.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareEqual.Double.cs
@@ -334,7 +334,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -342,7 +342,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -374,9 +379,11 @@ private void ValidateResult(void* left, void* right, void* result, [CallerMember
 
         private void ValidateResult(Double[] left, Double[] right, Double[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (BitConverter.DoubleToInt64Bits(result[0]) != ((left[0] == right[0]) ? -1 : 0))
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -384,19 +391,21 @@ private void ValidateResult(Double[] left, Double[] right, Double[] result, [Cal
                 {
                     if (BitConverter.DoubleToInt64Bits(result[i]) != ((left[i] == right[i]) ? -1 : 0))
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Sse2)}.{nameof(Sse2.CompareEqual)}<Double>(Vector128<Double>, Vector128<Double>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareEqual.Int16.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareEqual.Int16.cs
index d325b1ef1a31..8e4abab42fb4 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareEqual.Int16.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareEqual.Int16.cs
@@ -334,7 +334,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -342,7 +342,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -374,9 +379,11 @@ private void ValidateResult(void* left, void* right, void* result, [CallerMember
 
         private void ValidateResult(Int16[] left, Int16[] right, Int16[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (result[0] != ((left[0] == right[0]) ? unchecked((short)(-1)) : 0))
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -384,19 +391,21 @@ private void ValidateResult(Int16[] left, Int16[] right, Int16[] result, [Caller
                 {
                     if (result[i] != ((left[i] == right[i]) ? unchecked((short)(-1)) : 0))
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Sse2)}.{nameof(Sse2.CompareEqual)}<Int16>(Vector128<Int16>, Vector128<Int16>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareEqual.Int32.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareEqual.Int32.cs
index a7298a2155c9..d7e66c5d18d4 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareEqual.Int32.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareEqual.Int32.cs
@@ -334,7 +334,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -342,7 +342,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -374,9 +379,11 @@ private void ValidateResult(void* left, void* right, void* result, [CallerMember
 
         private void ValidateResult(Int32[] left, Int32[] right, Int32[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (result[0] != ((left[0] == right[0]) ? unchecked((int)(-1)) : 0))
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -384,19 +391,21 @@ private void ValidateResult(Int32[] left, Int32[] right, Int32[] result, [Caller
                 {
                     if (result[i] != ((left[i] == right[i]) ? unchecked((int)(-1)) : 0))
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Sse2)}.{nameof(Sse2.CompareEqual)}<Int32>(Vector128<Int32>, Vector128<Int32>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareEqual.SByte.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareEqual.SByte.cs
index 247079f507e4..8ca31e83cf1c 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareEqual.SByte.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareEqual.SByte.cs
@@ -334,7 +334,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -342,7 +342,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -374,9 +379,11 @@ private void ValidateResult(void* left, void* right, void* result, [CallerMember
 
         private void ValidateResult(SByte[] left, SByte[] right, SByte[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (result[0] != ((left[0] == right[0]) ? unchecked((sbyte)(-1)) : 0))
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -384,19 +391,21 @@ private void ValidateResult(SByte[] left, SByte[] right, SByte[] result, [Caller
                 {
                     if (result[i] != ((left[i] == right[i]) ? unchecked((sbyte)(-1)) : 0))
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Sse2)}.{nameof(Sse2.CompareEqual)}<SByte>(Vector128<SByte>, Vector128<SByte>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareEqual.UInt16.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareEqual.UInt16.cs
index 1dfc5cd24248..02dd10481ab2 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareEqual.UInt16.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareEqual.UInt16.cs
@@ -334,7 +334,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -342,7 +342,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -374,9 +379,11 @@ private void ValidateResult(void* left, void* right, void* result, [CallerMember
 
         private void ValidateResult(UInt16[] left, UInt16[] right, UInt16[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (result[0] != ((left[0] == right[0]) ? unchecked((ushort)(-1)) : 0))
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -384,19 +391,21 @@ private void ValidateResult(UInt16[] left, UInt16[] right, UInt16[] result, [Cal
                 {
                     if (result[i] != ((left[i] == right[i]) ? unchecked((ushort)(-1)) : 0))
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Sse2)}.{nameof(Sse2.CompareEqual)}<UInt16>(Vector128<UInt16>, Vector128<UInt16>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareEqual.UInt32.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareEqual.UInt32.cs
index 4f5997723e1b..3afc3c3e06b9 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareEqual.UInt32.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareEqual.UInt32.cs
@@ -334,7 +334,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -342,7 +342,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -374,9 +379,11 @@ private void ValidateResult(void* left, void* right, void* result, [CallerMember
 
         private void ValidateResult(UInt32[] left, UInt32[] right, UInt32[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (result[0] != ((left[0] == right[0]) ? unchecked((uint)(-1)) : 0))
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -384,19 +391,21 @@ private void ValidateResult(UInt32[] left, UInt32[] right, UInt32[] result, [Cal
                 {
                     if (result[i] != ((left[i] == right[i]) ? unchecked((uint)(-1)) : 0))
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Sse2)}.{nameof(Sse2.CompareEqual)}<UInt32>(Vector128<UInt32>, Vector128<UInt32>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareEqualOrderedScalar.Boolean.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareEqualOrderedScalar.Boolean.cs
index be6a5ff323ca..979a2ec99550 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareEqualOrderedScalar.Boolean.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareEqualOrderedScalar.Boolean.cs
@@ -317,7 +317,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -325,7 +325,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -355,13 +360,13 @@ private void ValidateResult(Double[] left, Double[] right, bool result, [CallerM
         {
             if ((left[0] == right[0]) != result)
             {
-                Succeeded = false;
-
                 TestLibrary.TestFramework.LogInformation($"{nameof(Sse2)}.{nameof(Sse2.CompareEqualOrderedScalar)}<Boolean>(Vector128<Double>, Vector128<Double>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareEqualScalar.Double.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareEqualScalar.Double.cs
index cf543adeaaf8..a4454f0873e6 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareEqualScalar.Double.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareEqualScalar.Double.cs
@@ -334,7 +334,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -342,7 +342,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -374,9 +379,11 @@ private void ValidateResult(void* left, void* right, void* result, [CallerMember
 
         private void ValidateResult(Double[] left, Double[] right, Double[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (BitConverter.DoubleToInt64Bits(result[0]) != ((left[0] == right[0]) ? -1 : 0))
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -384,19 +391,21 @@ private void ValidateResult(Double[] left, Double[] right, Double[] result, [Cal
                 {
                     if (BitConverter.DoubleToInt64Bits(left[i]) != BitConverter.DoubleToInt64Bits(result[i]))
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Sse2)}.{nameof(Sse2.CompareEqualScalar)}<Double>(Vector128<Double>, Vector128<Double>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareEqualUnorderedScalar.Boolean.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareEqualUnorderedScalar.Boolean.cs
index 27cbf162d310..b5c416b6df5a 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareEqualUnorderedScalar.Boolean.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareEqualUnorderedScalar.Boolean.cs
@@ -317,7 +317,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -325,7 +325,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -355,13 +360,13 @@ private void ValidateResult(Double[] left, Double[] right, bool result, [CallerM
         {
             if ((left[0] == right[0]) != result)
             {
-                Succeeded = false;
-
                 TestLibrary.TestFramework.LogInformation($"{nameof(Sse2)}.{nameof(Sse2.CompareEqualUnorderedScalar)}<Boolean>(Vector128<Double>, Vector128<Double>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareGreaterThan.Double.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareGreaterThan.Double.cs
index 69e912cd1591..91ac43275b4c 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareGreaterThan.Double.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareGreaterThan.Double.cs
@@ -334,7 +334,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -342,7 +342,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -374,9 +379,11 @@ private void ValidateResult(void* left, void* right, void* result, [CallerMember
 
         private void ValidateResult(Double[] left, Double[] right, Double[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (BitConverter.DoubleToInt64Bits(result[0]) != ((left[0] > right[0]) ? -1 : 0))
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -384,19 +391,21 @@ private void ValidateResult(Double[] left, Double[] right, Double[] result, [Cal
                 {
                     if (BitConverter.DoubleToInt64Bits(result[i]) != ((left[i] > right[i]) ? -1 : 0))
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Sse2)}.{nameof(Sse2.CompareGreaterThan)}<Double>(Vector128<Double>, Vector128<Double>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareGreaterThan.Int16.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareGreaterThan.Int16.cs
index 90b1a278f11f..81d95772104e 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareGreaterThan.Int16.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareGreaterThan.Int16.cs
@@ -334,7 +334,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -342,7 +342,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -374,9 +379,11 @@ private void ValidateResult(void* left, void* right, void* result, [CallerMember
 
         private void ValidateResult(Int16[] left, Int16[] right, Int16[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (result[0] != ((left[0] > right[0]) ? unchecked((short)(-1)) : 0))
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -384,19 +391,21 @@ private void ValidateResult(Int16[] left, Int16[] right, Int16[] result, [Caller
                 {
                     if (result[i] != ((left[i] > right[i]) ? unchecked((short)(-1)) : 0))
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Sse2)}.{nameof(Sse2.CompareGreaterThan)}<Int16>(Vector128<Int16>, Vector128<Int16>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareGreaterThan.Int32.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareGreaterThan.Int32.cs
index 98922609e1bf..08a7fcc0e470 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareGreaterThan.Int32.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareGreaterThan.Int32.cs
@@ -334,7 +334,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -342,7 +342,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -374,9 +379,11 @@ private void ValidateResult(void* left, void* right, void* result, [CallerMember
 
         private void ValidateResult(Int32[] left, Int32[] right, Int32[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (result[0] != ((left[0] > right[0]) ? unchecked((int)(-1)) : 0))
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -384,19 +391,21 @@ private void ValidateResult(Int32[] left, Int32[] right, Int32[] result, [Caller
                 {
                     if (result[i] != ((left[i] > right[i]) ? unchecked((int)(-1)) : 0))
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Sse2)}.{nameof(Sse2.CompareGreaterThan)}<Int32>(Vector128<Int32>, Vector128<Int32>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareGreaterThan.SByte.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareGreaterThan.SByte.cs
index 31ac233ea233..2c7eeaf3332b 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareGreaterThan.SByte.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareGreaterThan.SByte.cs
@@ -334,7 +334,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -342,7 +342,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -374,9 +379,11 @@ private void ValidateResult(void* left, void* right, void* result, [CallerMember
 
         private void ValidateResult(SByte[] left, SByte[] right, SByte[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (result[0] != ((left[0] > right[0]) ? unchecked((sbyte)(-1)) : 0))
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -384,19 +391,21 @@ private void ValidateResult(SByte[] left, SByte[] right, SByte[] result, [Caller
                 {
                     if (result[i] != ((left[i] > right[i]) ? unchecked((sbyte)(-1)) : 0))
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Sse2)}.{nameof(Sse2.CompareGreaterThan)}<SByte>(Vector128<SByte>, Vector128<SByte>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareGreaterThanOrEqual.Double.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareGreaterThanOrEqual.Double.cs
index 9f7a27027b66..0b5542e6ade3 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareGreaterThanOrEqual.Double.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareGreaterThanOrEqual.Double.cs
@@ -334,7 +334,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -342,7 +342,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -374,9 +379,11 @@ private void ValidateResult(void* left, void* right, void* result, [CallerMember
 
         private void ValidateResult(Double[] left, Double[] right, Double[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (BitConverter.DoubleToInt64Bits(result[0]) != ((left[0] >= right[0]) ? -1 : 0))
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -384,19 +391,21 @@ private void ValidateResult(Double[] left, Double[] right, Double[] result, [Cal
                 {
                     if (BitConverter.DoubleToInt64Bits(result[i]) != ((left[i] >= right[i]) ? -1 : 0))
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Sse2)}.{nameof(Sse2.CompareGreaterThanOrEqual)}<Double>(Vector128<Double>, Vector128<Double>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareGreaterThanOrEqualOrderedScalar.Boolean.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareGreaterThanOrEqualOrderedScalar.Boolean.cs
index 4e5534a003fb..c7a82b8e87d1 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareGreaterThanOrEqualOrderedScalar.Boolean.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareGreaterThanOrEqualOrderedScalar.Boolean.cs
@@ -317,7 +317,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -325,7 +325,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -355,13 +360,13 @@ private void ValidateResult(Double[] left, Double[] right, bool result, [CallerM
         {
             if ((left[0] >= right[0]) != result)
             {
-                Succeeded = false;
-
                 TestLibrary.TestFramework.LogInformation($"{nameof(Sse2)}.{nameof(Sse2.CompareGreaterThanOrEqualOrderedScalar)}<Boolean>(Vector128<Double>, Vector128<Double>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareGreaterThanOrEqualScalar.Double.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareGreaterThanOrEqualScalar.Double.cs
index 6a93fba9b723..489782058504 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareGreaterThanOrEqualScalar.Double.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareGreaterThanOrEqualScalar.Double.cs
@@ -334,7 +334,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -342,7 +342,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -374,9 +379,11 @@ private void ValidateResult(void* left, void* right, void* result, [CallerMember
 
         private void ValidateResult(Double[] left, Double[] right, Double[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (BitConverter.DoubleToInt64Bits(result[0]) != ((left[0] >= right[0]) ? -1 : 0))
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -384,19 +391,21 @@ private void ValidateResult(Double[] left, Double[] right, Double[] result, [Cal
                 {
                     if (BitConverter.DoubleToInt64Bits(left[i]) != BitConverter.DoubleToInt64Bits(result[i]))
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Sse2)}.{nameof(Sse2.CompareGreaterThanOrEqualScalar)}<Double>(Vector128<Double>, Vector128<Double>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareGreaterThanOrEqualUnorderedScalar.Boolean.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareGreaterThanOrEqualUnorderedScalar.Boolean.cs
index d7b4a90564d2..41f1acf2083e 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareGreaterThanOrEqualUnorderedScalar.Boolean.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareGreaterThanOrEqualUnorderedScalar.Boolean.cs
@@ -317,7 +317,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -325,7 +325,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -355,13 +360,13 @@ private void ValidateResult(Double[] left, Double[] right, bool result, [CallerM
         {
             if ((left[0] >= right[0]) != result)
             {
-                Succeeded = false;
-
                 TestLibrary.TestFramework.LogInformation($"{nameof(Sse2)}.{nameof(Sse2.CompareGreaterThanOrEqualUnorderedScalar)}<Boolean>(Vector128<Double>, Vector128<Double>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareGreaterThanOrderedScalar.Boolean.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareGreaterThanOrderedScalar.Boolean.cs
index d82d431293dd..1e1072c9198b 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareGreaterThanOrderedScalar.Boolean.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareGreaterThanOrderedScalar.Boolean.cs
@@ -317,7 +317,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -325,7 +325,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -355,13 +360,13 @@ private void ValidateResult(Double[] left, Double[] right, bool result, [CallerM
         {
             if ((left[0] > right[0]) != result)
             {
-                Succeeded = false;
-
                 TestLibrary.TestFramework.LogInformation($"{nameof(Sse2)}.{nameof(Sse2.CompareGreaterThanOrderedScalar)}<Boolean>(Vector128<Double>, Vector128<Double>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareGreaterThanScalar.Double.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareGreaterThanScalar.Double.cs
index e7ebc123bf0a..eea27d1758ad 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareGreaterThanScalar.Double.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareGreaterThanScalar.Double.cs
@@ -334,7 +334,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -342,7 +342,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -374,9 +379,11 @@ private void ValidateResult(void* left, void* right, void* result, [CallerMember
 
         private void ValidateResult(Double[] left, Double[] right, Double[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (BitConverter.DoubleToInt64Bits(result[0]) != ((left[0] > right[0]) ? -1 : 0))
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -384,19 +391,21 @@ private void ValidateResult(Double[] left, Double[] right, Double[] result, [Cal
                 {
                     if (BitConverter.DoubleToInt64Bits(left[i]) != BitConverter.DoubleToInt64Bits(result[i]))
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Sse2)}.{nameof(Sse2.CompareGreaterThanScalar)}<Double>(Vector128<Double>, Vector128<Double>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareGreaterThanUnorderedScalar.Boolean.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareGreaterThanUnorderedScalar.Boolean.cs
index fe920b6f0001..2e208d4e18a4 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareGreaterThanUnorderedScalar.Boolean.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareGreaterThanUnorderedScalar.Boolean.cs
@@ -317,7 +317,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -325,7 +325,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -355,13 +360,13 @@ private void ValidateResult(Double[] left, Double[] right, bool result, [CallerM
         {
             if ((left[0] > right[0]) != result)
             {
-                Succeeded = false;
-
                 TestLibrary.TestFramework.LogInformation($"{nameof(Sse2)}.{nameof(Sse2.CompareGreaterThanUnorderedScalar)}<Boolean>(Vector128<Double>, Vector128<Double>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareLessThan.Double.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareLessThan.Double.cs
index 47cf82452893..6b73730b095c 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareLessThan.Double.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareLessThan.Double.cs
@@ -334,7 +334,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -342,7 +342,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -374,9 +379,11 @@ private void ValidateResult(void* left, void* right, void* result, [CallerMember
 
         private void ValidateResult(Double[] left, Double[] right, Double[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (BitConverter.DoubleToInt64Bits(result[0]) != ((left[0] < right[0]) ? -1 : 0))
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -384,19 +391,21 @@ private void ValidateResult(Double[] left, Double[] right, Double[] result, [Cal
                 {
                     if (BitConverter.DoubleToInt64Bits(result[i]) != ((left[i] < right[i]) ? -1 : 0))
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Sse2)}.{nameof(Sse2.CompareLessThan)}<Double>(Vector128<Double>, Vector128<Double>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareLessThan.Int16.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareLessThan.Int16.cs
index ed88d91e2a1a..aa4292a9ca04 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareLessThan.Int16.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareLessThan.Int16.cs
@@ -334,7 +334,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -342,7 +342,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -374,9 +379,11 @@ private void ValidateResult(void* left, void* right, void* result, [CallerMember
 
         private void ValidateResult(Int16[] left, Int16[] right, Int16[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (result[0] != ((left[0] < right[0]) ? unchecked((short)(-1)) : 0))
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -384,19 +391,21 @@ private void ValidateResult(Int16[] left, Int16[] right, Int16[] result, [Caller
                 {
                     if (result[i] != ((left[i] < right[i]) ? unchecked((short)(-1)) : 0))
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Sse2)}.{nameof(Sse2.CompareLessThan)}<Int16>(Vector128<Int16>, Vector128<Int16>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareLessThan.Int32.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareLessThan.Int32.cs
index c784dcf02d22..802ea69fce10 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareLessThan.Int32.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareLessThan.Int32.cs
@@ -334,7 +334,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -342,7 +342,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -374,9 +379,11 @@ private void ValidateResult(void* left, void* right, void* result, [CallerMember
 
         private void ValidateResult(Int32[] left, Int32[] right, Int32[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (result[0] != ((left[0] < right[0]) ? unchecked((int)(-1)) : 0))
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -384,19 +391,21 @@ private void ValidateResult(Int32[] left, Int32[] right, Int32[] result, [Caller
                 {
                     if (result[i] != ((left[i] < right[i]) ? unchecked((int)(-1)) : 0))
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Sse2)}.{nameof(Sse2.CompareLessThan)}<Int32>(Vector128<Int32>, Vector128<Int32>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareLessThan.SByte.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareLessThan.SByte.cs
index 589118979540..1dcded41e448 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareLessThan.SByte.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareLessThan.SByte.cs
@@ -334,7 +334,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -342,7 +342,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -374,9 +379,11 @@ private void ValidateResult(void* left, void* right, void* result, [CallerMember
 
         private void ValidateResult(SByte[] left, SByte[] right, SByte[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (result[0] != ((left[0] < right[0]) ? unchecked((sbyte)(-1)) : 0))
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -384,19 +391,21 @@ private void ValidateResult(SByte[] left, SByte[] right, SByte[] result, [Caller
                 {
                     if (result[i] != ((left[i] < right[i]) ? unchecked((sbyte)(-1)) : 0))
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Sse2)}.{nameof(Sse2.CompareLessThan)}<SByte>(Vector128<SByte>, Vector128<SByte>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareLessThanOrEqual.Double.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareLessThanOrEqual.Double.cs
index e15d4fb57d1f..eafc3ce5ca97 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareLessThanOrEqual.Double.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareLessThanOrEqual.Double.cs
@@ -334,7 +334,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -342,7 +342,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -374,9 +379,11 @@ private void ValidateResult(void* left, void* right, void* result, [CallerMember
 
         private void ValidateResult(Double[] left, Double[] right, Double[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (BitConverter.DoubleToInt64Bits(result[0]) != ((left[0] <= right[0]) ? -1 : 0))
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -384,19 +391,21 @@ private void ValidateResult(Double[] left, Double[] right, Double[] result, [Cal
                 {
                     if (BitConverter.DoubleToInt64Bits(result[i]) != ((left[i] <= right[i]) ? -1 : 0))
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Sse2)}.{nameof(Sse2.CompareLessThanOrEqual)}<Double>(Vector128<Double>, Vector128<Double>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareLessThanOrEqualOrderedScalar.Boolean.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareLessThanOrEqualOrderedScalar.Boolean.cs
index c57feffadcb4..05e2e2fefc90 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareLessThanOrEqualOrderedScalar.Boolean.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareLessThanOrEqualOrderedScalar.Boolean.cs
@@ -317,7 +317,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -325,7 +325,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -355,13 +360,13 @@ private void ValidateResult(Double[] left, Double[] right, bool result, [CallerM
         {
             if ((left[0] <= right[0]) != result)
             {
-                Succeeded = false;
-
                 TestLibrary.TestFramework.LogInformation($"{nameof(Sse2)}.{nameof(Sse2.CompareLessThanOrEqualOrderedScalar)}<Boolean>(Vector128<Double>, Vector128<Double>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareLessThanOrEqualScalar.Double.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareLessThanOrEqualScalar.Double.cs
index 4b074fc2ef4c..b981195da0be 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareLessThanOrEqualScalar.Double.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareLessThanOrEqualScalar.Double.cs
@@ -334,7 +334,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -342,7 +342,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -374,9 +379,11 @@ private void ValidateResult(void* left, void* right, void* result, [CallerMember
 
         private void ValidateResult(Double[] left, Double[] right, Double[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (BitConverter.DoubleToInt64Bits(result[0]) != ((left[0] <= right[0]) ? -1 : 0))
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -384,19 +391,21 @@ private void ValidateResult(Double[] left, Double[] right, Double[] result, [Cal
                 {
                     if (BitConverter.DoubleToInt64Bits(left[i]) != BitConverter.DoubleToInt64Bits(result[i]))
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Sse2)}.{nameof(Sse2.CompareLessThanOrEqualScalar)}<Double>(Vector128<Double>, Vector128<Double>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareLessThanOrEqualUnorderedScalar.Boolean.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareLessThanOrEqualUnorderedScalar.Boolean.cs
index 6c6341fcf46b..b9ec317045fa 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareLessThanOrEqualUnorderedScalar.Boolean.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareLessThanOrEqualUnorderedScalar.Boolean.cs
@@ -317,7 +317,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -325,7 +325,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -355,13 +360,13 @@ private void ValidateResult(Double[] left, Double[] right, bool result, [CallerM
         {
             if ((left[0] <= right[0]) != result)
             {
-                Succeeded = false;
-
                 TestLibrary.TestFramework.LogInformation($"{nameof(Sse2)}.{nameof(Sse2.CompareLessThanOrEqualUnorderedScalar)}<Boolean>(Vector128<Double>, Vector128<Double>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareLessThanOrderedScalar.Boolean.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareLessThanOrderedScalar.Boolean.cs
index 3671313d06d6..0cd4106abcd0 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareLessThanOrderedScalar.Boolean.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareLessThanOrderedScalar.Boolean.cs
@@ -317,7 +317,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -325,7 +325,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -355,13 +360,13 @@ private void ValidateResult(Double[] left, Double[] right, bool result, [CallerM
         {
             if ((left[0] < right[0]) != result)
             {
-                Succeeded = false;
-
                 TestLibrary.TestFramework.LogInformation($"{nameof(Sse2)}.{nameof(Sse2.CompareLessThanOrderedScalar)}<Boolean>(Vector128<Double>, Vector128<Double>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareLessThanScalar.Double.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareLessThanScalar.Double.cs
index 3f454346cf39..01a6ba106c25 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareLessThanScalar.Double.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareLessThanScalar.Double.cs
@@ -334,7 +334,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -342,7 +342,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -374,9 +379,11 @@ private void ValidateResult(void* left, void* right, void* result, [CallerMember
 
         private void ValidateResult(Double[] left, Double[] right, Double[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (BitConverter.DoubleToInt64Bits(result[0]) != ((left[0] < right[0]) ? -1 : 0))
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -384,19 +391,21 @@ private void ValidateResult(Double[] left, Double[] right, Double[] result, [Cal
                 {
                     if (BitConverter.DoubleToInt64Bits(left[i]) != BitConverter.DoubleToInt64Bits(result[i]))
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Sse2)}.{nameof(Sse2.CompareLessThanScalar)}<Double>(Vector128<Double>, Vector128<Double>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareLessThanUnorderedScalar.Boolean.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareLessThanUnorderedScalar.Boolean.cs
index 5244aa51ca15..36d688f5f2e8 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareLessThanUnorderedScalar.Boolean.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareLessThanUnorderedScalar.Boolean.cs
@@ -317,7 +317,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -325,7 +325,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -355,13 +360,13 @@ private void ValidateResult(Double[] left, Double[] right, bool result, [CallerM
         {
             if ((left[0] < right[0]) != result)
             {
-                Succeeded = false;
-
                 TestLibrary.TestFramework.LogInformation($"{nameof(Sse2)}.{nameof(Sse2.CompareLessThanUnorderedScalar)}<Boolean>(Vector128<Double>, Vector128<Double>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareNotEqual.Double.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareNotEqual.Double.cs
index 3350852bc444..a50fd0e9e8c6 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareNotEqual.Double.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareNotEqual.Double.cs
@@ -334,7 +334,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -342,7 +342,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -374,9 +379,11 @@ private void ValidateResult(void* left, void* right, void* result, [CallerMember
 
         private void ValidateResult(Double[] left, Double[] right, Double[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (BitConverter.DoubleToInt64Bits(result[0]) != ((left[0] != right[0]) ? -1 : 0))
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -384,19 +391,21 @@ private void ValidateResult(Double[] left, Double[] right, Double[] result, [Cal
                 {
                     if (BitConverter.DoubleToInt64Bits(result[i]) != ((left[i] != right[i]) ? -1 : 0))
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Sse2)}.{nameof(Sse2.CompareNotEqual)}<Double>(Vector128<Double>, Vector128<Double>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareNotEqualOrderedScalar.Boolean.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareNotEqualOrderedScalar.Boolean.cs
index 7b5164328047..c8367f7751a5 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareNotEqualOrderedScalar.Boolean.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareNotEqualOrderedScalar.Boolean.cs
@@ -317,7 +317,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -325,7 +325,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -355,13 +360,13 @@ private void ValidateResult(Double[] left, Double[] right, bool result, [CallerM
         {
             if ((left[0] != right[0]) != result)
             {
-                Succeeded = false;
-
                 TestLibrary.TestFramework.LogInformation($"{nameof(Sse2)}.{nameof(Sse2.CompareNotEqualOrderedScalar)}<Boolean>(Vector128<Double>, Vector128<Double>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareNotEqualScalar.Double.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareNotEqualScalar.Double.cs
index 1b10b718e1ae..698a4755efe5 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareNotEqualScalar.Double.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareNotEqualScalar.Double.cs
@@ -334,7 +334,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -342,7 +342,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -374,9 +379,11 @@ private void ValidateResult(void* left, void* right, void* result, [CallerMember
 
         private void ValidateResult(Double[] left, Double[] right, Double[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (BitConverter.DoubleToInt64Bits(result[0]) != ((left[0] != right[0]) ? -1 : 0))
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -384,19 +391,21 @@ private void ValidateResult(Double[] left, Double[] right, Double[] result, [Cal
                 {
                     if (BitConverter.DoubleToInt64Bits(left[i]) != BitConverter.DoubleToInt64Bits(result[i]))
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Sse2)}.{nameof(Sse2.CompareNotEqualScalar)}<Double>(Vector128<Double>, Vector128<Double>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareNotEqualUnorderedScalar.Boolean.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareNotEqualUnorderedScalar.Boolean.cs
index fc552a063066..4199cd8ec3b6 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareNotEqualUnorderedScalar.Boolean.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareNotEqualUnorderedScalar.Boolean.cs
@@ -317,7 +317,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -325,7 +325,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -355,13 +360,13 @@ private void ValidateResult(Double[] left, Double[] right, bool result, [CallerM
         {
             if ((left[0] != right[0]) != result)
             {
-                Succeeded = false;
-
                 TestLibrary.TestFramework.LogInformation($"{nameof(Sse2)}.{nameof(Sse2.CompareNotEqualUnorderedScalar)}<Boolean>(Vector128<Double>, Vector128<Double>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareNotGreaterThan.Double.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareNotGreaterThan.Double.cs
index 84eb237725d5..8bbe0fe7ec95 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareNotGreaterThan.Double.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareNotGreaterThan.Double.cs
@@ -334,7 +334,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -342,7 +342,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -374,9 +379,11 @@ private void ValidateResult(void* left, void* right, void* result, [CallerMember
 
         private void ValidateResult(Double[] left, Double[] right, Double[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (BitConverter.DoubleToInt64Bits(result[0]) != (!(left[0] > right[0]) ? -1 : 0))
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -384,19 +391,21 @@ private void ValidateResult(Double[] left, Double[] right, Double[] result, [Cal
                 {
                     if (BitConverter.DoubleToInt64Bits(result[i]) != (!(left[i] > right[i]) ? -1 : 0))
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Sse2)}.{nameof(Sse2.CompareNotGreaterThan)}<Double>(Vector128<Double>, Vector128<Double>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareNotGreaterThanOrEqual.Double.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareNotGreaterThanOrEqual.Double.cs
index a9fc74b6b5a0..6709491f7655 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareNotGreaterThanOrEqual.Double.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareNotGreaterThanOrEqual.Double.cs
@@ -334,7 +334,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -342,7 +342,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -374,9 +379,11 @@ private void ValidateResult(void* left, void* right, void* result, [CallerMember
 
         private void ValidateResult(Double[] left, Double[] right, Double[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (BitConverter.DoubleToInt64Bits(result[0]) != (!(left[0] >= right[0]) ? -1 : 0))
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -384,19 +391,21 @@ private void ValidateResult(Double[] left, Double[] right, Double[] result, [Cal
                 {
                     if (BitConverter.DoubleToInt64Bits(result[i]) != (!(left[i] >= right[i]) ? -1 : 0))
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Sse2)}.{nameof(Sse2.CompareNotGreaterThanOrEqual)}<Double>(Vector128<Double>, Vector128<Double>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareNotGreaterThanOrEqualScalar.Double.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareNotGreaterThanOrEqualScalar.Double.cs
index a4d56c956a92..c14d13f93218 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareNotGreaterThanOrEqualScalar.Double.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareNotGreaterThanOrEqualScalar.Double.cs
@@ -334,7 +334,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -342,7 +342,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -374,9 +379,11 @@ private void ValidateResult(void* left, void* right, void* result, [CallerMember
 
         private void ValidateResult(Double[] left, Double[] right, Double[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (BitConverter.DoubleToInt64Bits(result[0]) != (!(left[0] >= right[0]) ? -1 : 0))
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -384,19 +391,21 @@ private void ValidateResult(Double[] left, Double[] right, Double[] result, [Cal
                 {
                     if (BitConverter.DoubleToInt64Bits(left[i]) != BitConverter.DoubleToInt64Bits(result[i]))
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Sse2)}.{nameof(Sse2.CompareNotGreaterThanOrEqualScalar)}<Double>(Vector128<Double>, Vector128<Double>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareNotGreaterThanScalar.Double.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareNotGreaterThanScalar.Double.cs
index a42a3a8a2606..1dcc837ff131 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareNotGreaterThanScalar.Double.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareNotGreaterThanScalar.Double.cs
@@ -334,7 +334,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -342,7 +342,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -374,9 +379,11 @@ private void ValidateResult(void* left, void* right, void* result, [CallerMember
 
         private void ValidateResult(Double[] left, Double[] right, Double[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (BitConverter.DoubleToInt64Bits(result[0]) != (!(left[0] > right[0]) ? -1 : 0))
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -384,19 +391,21 @@ private void ValidateResult(Double[] left, Double[] right, Double[] result, [Cal
                 {
                     if (BitConverter.DoubleToInt64Bits(left[i]) != BitConverter.DoubleToInt64Bits(result[i]))
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Sse2)}.{nameof(Sse2.CompareNotGreaterThanScalar)}<Double>(Vector128<Double>, Vector128<Double>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareNotLessThan.Double.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareNotLessThan.Double.cs
index afb0af16dce4..0554cbff795f 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareNotLessThan.Double.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareNotLessThan.Double.cs
@@ -334,7 +334,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -342,7 +342,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -374,9 +379,11 @@ private void ValidateResult(void* left, void* right, void* result, [CallerMember
 
         private void ValidateResult(Double[] left, Double[] right, Double[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (BitConverter.DoubleToInt64Bits(result[0]) != (!(left[0] < right[0]) ? -1 : 0))
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -384,19 +391,21 @@ private void ValidateResult(Double[] left, Double[] right, Double[] result, [Cal
                 {
                     if (BitConverter.DoubleToInt64Bits(result[i]) != (!(left[i] < right[i]) ? -1 : 0))
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Sse2)}.{nameof(Sse2.CompareNotLessThan)}<Double>(Vector128<Double>, Vector128<Double>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareNotLessThanOrEqual.Double.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareNotLessThanOrEqual.Double.cs
index f5263fd0ebb0..f1753a56eee4 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareNotLessThanOrEqual.Double.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareNotLessThanOrEqual.Double.cs
@@ -334,7 +334,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -342,7 +342,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -374,9 +379,11 @@ private void ValidateResult(void* left, void* right, void* result, [CallerMember
 
         private void ValidateResult(Double[] left, Double[] right, Double[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (BitConverter.DoubleToInt64Bits(result[0]) != (!(left[0] <= right[0]) ? -1 : 0))
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -384,19 +391,21 @@ private void ValidateResult(Double[] left, Double[] right, Double[] result, [Cal
                 {
                     if (BitConverter.DoubleToInt64Bits(result[i]) != (!(left[i] <= right[i]) ? -1 : 0))
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Sse2)}.{nameof(Sse2.CompareNotLessThanOrEqual)}<Double>(Vector128<Double>, Vector128<Double>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareNotLessThanOrEqualScalar.Double.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareNotLessThanOrEqualScalar.Double.cs
index 8d7e7b5616ba..b833fc44badc 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareNotLessThanOrEqualScalar.Double.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareNotLessThanOrEqualScalar.Double.cs
@@ -334,7 +334,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -342,7 +342,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -374,9 +379,11 @@ private void ValidateResult(void* left, void* right, void* result, [CallerMember
 
         private void ValidateResult(Double[] left, Double[] right, Double[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (BitConverter.DoubleToInt64Bits(result[0]) != (!(left[0] <= right[0]) ? -1 : 0))
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -384,19 +391,21 @@ private void ValidateResult(Double[] left, Double[] right, Double[] result, [Cal
                 {
                     if (BitConverter.DoubleToInt64Bits(left[i]) != BitConverter.DoubleToInt64Bits(result[i]))
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Sse2)}.{nameof(Sse2.CompareNotLessThanOrEqualScalar)}<Double>(Vector128<Double>, Vector128<Double>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareNotLessThanScalar.Double.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareNotLessThanScalar.Double.cs
index 1a841770acb7..867f5577133a 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareNotLessThanScalar.Double.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareNotLessThanScalar.Double.cs
@@ -334,7 +334,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -342,7 +342,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -374,9 +379,11 @@ private void ValidateResult(void* left, void* right, void* result, [CallerMember
 
         private void ValidateResult(Double[] left, Double[] right, Double[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (BitConverter.DoubleToInt64Bits(result[0]) != (!(left[0] < right[0]) ? -1 : 0))
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -384,19 +391,21 @@ private void ValidateResult(Double[] left, Double[] right, Double[] result, [Cal
                 {
                     if (BitConverter.DoubleToInt64Bits(left[i]) != BitConverter.DoubleToInt64Bits(result[i]))
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Sse2)}.{nameof(Sse2.CompareNotLessThanScalar)}<Double>(Vector128<Double>, Vector128<Double>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareOrdered.Double.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareOrdered.Double.cs
index 64efe0ef97c0..8ce57b5e392c 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareOrdered.Double.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareOrdered.Double.cs
@@ -334,7 +334,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -342,7 +342,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -374,9 +379,11 @@ private void ValidateResult(void* left, void* right, void* result, [CallerMember
 
         private void ValidateResult(Double[] left, Double[] right, Double[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (BitConverter.DoubleToInt64Bits(result[0]) != ((!double.IsNaN(left[0]) && !double.IsNaN(right[0])) ? -1 : 0))
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -384,19 +391,21 @@ private void ValidateResult(Double[] left, Double[] right, Double[] result, [Cal
                 {
                     if (BitConverter.DoubleToInt64Bits(result[i]) != ((!double.IsNaN(left[i]) && !double.IsNaN(right[i])) ? -1 : 0))
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Sse2)}.{nameof(Sse2.CompareOrdered)}<Double>(Vector128<Double>, Vector128<Double>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareOrderedScalar.Double.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareOrderedScalar.Double.cs
index ae47b047fe65..caa0bd94909c 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareOrderedScalar.Double.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareOrderedScalar.Double.cs
@@ -334,7 +334,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -342,7 +342,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -374,9 +379,11 @@ private void ValidateResult(void* left, void* right, void* result, [CallerMember
 
         private void ValidateResult(Double[] left, Double[] right, Double[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (BitConverter.DoubleToInt64Bits(result[0]) != ((!double.IsNaN(left[0]) && !double.IsNaN(right[0])) ? -1 : 0))
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -384,19 +391,21 @@ private void ValidateResult(Double[] left, Double[] right, Double[] result, [Cal
                 {
                     if (BitConverter.DoubleToInt64Bits(left[i]) != BitConverter.DoubleToInt64Bits(result[i]))
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Sse2)}.{nameof(Sse2.CompareOrderedScalar)}<Double>(Vector128<Double>, Vector128<Double>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareUnordered.Double.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareUnordered.Double.cs
index 2104b3d548d9..36571cd1edd1 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareUnordered.Double.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareUnordered.Double.cs
@@ -334,7 +334,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -342,7 +342,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -374,9 +379,11 @@ private void ValidateResult(void* left, void* right, void* result, [CallerMember
 
         private void ValidateResult(Double[] left, Double[] right, Double[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (BitConverter.DoubleToInt64Bits(result[0]) != ((double.IsNaN(left[0]) || double.IsNaN(right[0])) ? -1 : 0))
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -384,19 +391,21 @@ private void ValidateResult(Double[] left, Double[] right, Double[] result, [Cal
                 {
                     if (BitConverter.DoubleToInt64Bits(result[i]) != ((double.IsNaN(left[i]) || double.IsNaN(right[i])) ? -1 : 0))
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Sse2)}.{nameof(Sse2.CompareUnordered)}<Double>(Vector128<Double>, Vector128<Double>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareUnorderedScalar.Double.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareUnorderedScalar.Double.cs
index 209ff856d108..a09dac129fc7 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareUnorderedScalar.Double.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareUnorderedScalar.Double.cs
@@ -334,7 +334,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -342,7 +342,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -374,9 +379,11 @@ private void ValidateResult(void* left, void* right, void* result, [CallerMember
 
         private void ValidateResult(Double[] left, Double[] right, Double[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (BitConverter.DoubleToInt64Bits(result[0]) != ((double.IsNaN(left[0]) || double.IsNaN(right[0])) ? -1 : 0))
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -384,19 +391,21 @@ private void ValidateResult(Double[] left, Double[] right, Double[] result, [Cal
                 {
                     if (BitConverter.DoubleToInt64Bits(left[i]) != BitConverter.DoubleToInt64Bits(result[i]))
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Sse2)}.{nameof(Sse2.CompareUnorderedScalar)}<Double>(Vector128<Double>, Vector128<Double>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/ConvertToInt32.Vector128Double.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/ConvertToInt32.Vector128Double.cs
index 240246477c78..284e0577a478 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/ConvertToInt32.Vector128Double.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/ConvertToInt32.Vector128Double.cs
@@ -296,7 +296,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -304,7 +304,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -324,17 +329,21 @@ private void ValidateResult(void* firstOp, Int32 result, [CallerMemberName] stri
 
         private void ValidateResult(Double[] firstOp, Int32 result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if ((int)Math.Round(firstOp[0]) != result)
             {
-                Succeeded = false;
+                succeeded = false;
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Sse2)}.{nameof(Sse2.ConvertToInt32)}<Int32>(Vector128<Double>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"  firstOp: ({string.Join(", ", firstOp)})");
                 TestLibrary.TestFramework.LogInformation($"   result: result");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/ConvertToInt32.Vector128Int32.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/ConvertToInt32.Vector128Int32.cs
index 2fd24190a16a..0667343e1d8c 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/ConvertToInt32.Vector128Int32.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/ConvertToInt32.Vector128Int32.cs
@@ -296,7 +296,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -304,7 +304,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -324,17 +329,21 @@ private void ValidateResult(void* firstOp, Int32 result, [CallerMemberName] stri
 
         private void ValidateResult(Int32[] firstOp, Int32 result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (firstOp[0] != result)
             {
-                Succeeded = false;
+                succeeded = false;
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Sse2)}.{nameof(Sse2.ConvertToInt32)}<Int32>(Vector128<Int32>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"  firstOp: ({string.Join(", ", firstOp)})");
                 TestLibrary.TestFramework.LogInformation($"   result: result");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/ConvertToInt32WithTruncation.Vector128Double.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/ConvertToInt32WithTruncation.Vector128Double.cs
index 29b0953ece31..8dd705f37a47 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/ConvertToInt32WithTruncation.Vector128Double.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/ConvertToInt32WithTruncation.Vector128Double.cs
@@ -296,7 +296,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -304,7 +304,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -324,17 +329,21 @@ private void ValidateResult(void* firstOp, Int32 result, [CallerMemberName] stri
 
         private void ValidateResult(Double[] firstOp, Int32 result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if ((int) firstOp[0] != result)
             {
-                Succeeded = false;
+                succeeded = false;
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Sse2)}.{nameof(Sse2.ConvertToInt32WithTruncation)}<Int32>(Vector128<Double>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"  firstOp: ({string.Join(", ", firstOp)})");
                 TestLibrary.TestFramework.LogInformation($"   result: result");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/ConvertToInt64.Vector128Double.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/ConvertToInt64.Vector128Double.cs
index 4c76f38f093f..c6952d4e8656 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/ConvertToInt64.Vector128Double.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/ConvertToInt64.Vector128Double.cs
@@ -296,7 +296,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -304,7 +304,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -324,17 +329,21 @@ private void ValidateResult(void* firstOp, Int64 result, [CallerMemberName] stri
 
         private void ValidateResult(Double[] firstOp, Int64 result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if ((long)Math.Round(firstOp[0]) != result)
             {
-                Succeeded = false;
+                succeeded = false;
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Sse2)}.{nameof(Sse2.ConvertToInt64)}<Int64>(Vector128<Double>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"  firstOp: ({string.Join(", ", firstOp)})");
                 TestLibrary.TestFramework.LogInformation($"   result: result");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/ConvertToInt64.Vector128Int64.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/ConvertToInt64.Vector128Int64.cs
index 204eeb599e3f..50ae137bd31e 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/ConvertToInt64.Vector128Int64.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/ConvertToInt64.Vector128Int64.cs
@@ -296,7 +296,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -304,7 +304,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -324,17 +329,21 @@ private void ValidateResult(void* firstOp, Int64 result, [CallerMemberName] stri
 
         private void ValidateResult(Int64[] firstOp, Int64 result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (firstOp[0] != result)
             {
-                Succeeded = false;
+                succeeded = false;
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Sse2)}.{nameof(Sse2.ConvertToInt64)}<Int64>(Vector128<Int64>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"  firstOp: ({string.Join(", ", firstOp)})");
                 TestLibrary.TestFramework.LogInformation($"   result: result");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/ConvertToInt64WithTruncation.Vector128Double.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/ConvertToInt64WithTruncation.Vector128Double.cs
index e2daa26b72a9..8b423b71c519 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/ConvertToInt64WithTruncation.Vector128Double.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/ConvertToInt64WithTruncation.Vector128Double.cs
@@ -296,7 +296,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -304,7 +304,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -324,17 +329,21 @@ private void ValidateResult(void* firstOp, Int64 result, [CallerMemberName] stri
 
         private void ValidateResult(Double[] firstOp, Int64 result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if ((long) firstOp[0] != result)
             {
-                Succeeded = false;
+                succeeded = false;
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Sse2)}.{nameof(Sse2.ConvertToInt64WithTruncation)}<Int64>(Vector128<Double>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"  firstOp: ({string.Join(", ", firstOp)})");
                 TestLibrary.TestFramework.LogInformation($"   result: result");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/ConvertToUInt32.Vector128UInt32.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/ConvertToUInt32.Vector128UInt32.cs
index 7536702ab8e3..40877c3523c9 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/ConvertToUInt32.Vector128UInt32.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/ConvertToUInt32.Vector128UInt32.cs
@@ -296,7 +296,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -304,7 +304,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -324,17 +329,21 @@ private void ValidateResult(void* firstOp, UInt32 result, [CallerMemberName] str
 
         private void ValidateResult(UInt32[] firstOp, UInt32 result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (firstOp[0] != result)
             {
-                Succeeded = false;
+                succeeded = false;
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Sse2)}.{nameof(Sse2.ConvertToUInt32)}<UInt32>(Vector128<UInt32>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"  firstOp: ({string.Join(", ", firstOp)})");
                 TestLibrary.TestFramework.LogInformation($"   result: result");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/ConvertToUInt64.Vector128UInt64.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/ConvertToUInt64.Vector128UInt64.cs
index a1550b37dea4..31df382653da 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/ConvertToUInt64.Vector128UInt64.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/ConvertToUInt64.Vector128UInt64.cs
@@ -296,7 +296,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -304,7 +304,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -324,17 +329,21 @@ private void ValidateResult(void* firstOp, UInt64 result, [CallerMemberName] str
 
         private void ValidateResult(UInt64[] firstOp, UInt64 result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (firstOp[0] != result)
             {
-                Succeeded = false;
+                succeeded = false;
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Sse2)}.{nameof(Sse2.ConvertToUInt64)}<UInt64>(Vector128<UInt64>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"  firstOp: ({string.Join(", ", firstOp)})");
                 TestLibrary.TestFramework.LogInformation($"   result: result");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/ConvertToVector128Double.Vector128Int32.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/ConvertToVector128Double.Vector128Int32.cs
index bb4db2be671d..7e023ed2e53b 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/ConvertToVector128Double.Vector128Int32.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/ConvertToVector128Double.Vector128Int32.cs
@@ -312,7 +312,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -320,7 +320,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -348,9 +353,11 @@ private void ValidateResult(void* firstOp, void* result, [CallerMemberName] stri
 
         private void ValidateResult(Int32[] firstOp, Double[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (BitConverter.DoubleToInt64Bits(result[0]) != BitConverter.DoubleToInt64Bits(firstOp[0]))
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -358,18 +365,20 @@ private void ValidateResult(Int32[] firstOp, Double[] result, [CallerMemberName]
                 {
                     if (BitConverter.DoubleToInt64Bits(result[i % 2]) != BitConverter.DoubleToInt64Bits(firstOp[i % 2]))
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Sse2)}.{nameof(Sse2.ConvertToVector128Double)}<Double>(Vector128<Int32>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"  firstOp: ({string.Join(", ", firstOp)})");
                 TestLibrary.TestFramework.LogInformation($"   result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/ConvertToVector128Double.Vector128Single.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/ConvertToVector128Double.Vector128Single.cs
index eb64bc92d20a..b297c8dec7cf 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/ConvertToVector128Double.Vector128Single.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/ConvertToVector128Double.Vector128Single.cs
@@ -312,7 +312,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -320,7 +320,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -348,9 +353,11 @@ private void ValidateResult(void* firstOp, void* result, [CallerMemberName] stri
 
         private void ValidateResult(Single[] firstOp, Double[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (BitConverter.DoubleToInt64Bits(result[0]) != BitConverter.DoubleToInt64Bits(firstOp[0]))
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -358,18 +365,20 @@ private void ValidateResult(Single[] firstOp, Double[] result, [CallerMemberName
                 {
                     if (BitConverter.DoubleToInt64Bits(result[i]) != BitConverter.DoubleToInt64Bits(firstOp[i]))
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Sse2)}.{nameof(Sse2.ConvertToVector128Double)}<Double>(Vector128<Single>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"  firstOp: ({string.Join(", ", firstOp)})");
                 TestLibrary.TestFramework.LogInformation($"   result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/ConvertToVector128Int32.Vector128Double.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/ConvertToVector128Int32.Vector128Double.cs
index cddce9ce5e0e..ea30c1c6f3ae 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/ConvertToVector128Int32.Vector128Double.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/ConvertToVector128Int32.Vector128Double.cs
@@ -312,7 +312,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -320,7 +320,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -348,9 +353,11 @@ private void ValidateResult(void* firstOp, void* result, [CallerMemberName] stri
 
         private void ValidateResult(Double[] firstOp, Int32[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (result[0] != (int)Math.Round(firstOp[0]))
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -358,18 +365,20 @@ private void ValidateResult(Double[] firstOp, Int32[] result, [CallerMemberName]
                 {
                     if (result[i] != ((i < 2) ? (int)Math.Round(firstOp[i]) : 0))
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Sse2)}.{nameof(Sse2.ConvertToVector128Int32)}<Int32>(Vector128<Double>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"  firstOp: ({string.Join(", ", firstOp)})");
                 TestLibrary.TestFramework.LogInformation($"   result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/ConvertToVector128Int32.Vector128Single.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/ConvertToVector128Int32.Vector128Single.cs
index e7d803948ffa..2271c5bbec69 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/ConvertToVector128Int32.Vector128Single.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/ConvertToVector128Int32.Vector128Single.cs
@@ -312,7 +312,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -320,7 +320,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -348,9 +353,11 @@ private void ValidateResult(void* firstOp, void* result, [CallerMemberName] stri
 
         private void ValidateResult(Single[] firstOp, Int32[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (result[0] != (int)MathF.Round(firstOp[0]))
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -358,18 +365,20 @@ private void ValidateResult(Single[] firstOp, Int32[] result, [CallerMemberName]
                 {
                     if (result[i] != (int) MathF.Round(firstOp[i], 0))
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Sse2)}.{nameof(Sse2.ConvertToVector128Int32)}<Int32>(Vector128<Single>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"  firstOp: ({string.Join(", ", firstOp)})");
                 TestLibrary.TestFramework.LogInformation($"   result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/ConvertToVector128Int32WithTruncation.Vector128Double.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/ConvertToVector128Int32WithTruncation.Vector128Double.cs
index 51ac481a2bae..a5e2e287f259 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/ConvertToVector128Int32WithTruncation.Vector128Double.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/ConvertToVector128Int32WithTruncation.Vector128Double.cs
@@ -312,7 +312,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -320,7 +320,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -348,9 +353,11 @@ private void ValidateResult(void* firstOp, void* result, [CallerMemberName] stri
 
         private void ValidateResult(Double[] firstOp, Int32[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (result[0] != (int)firstOp[0])
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -358,18 +365,20 @@ private void ValidateResult(Double[] firstOp, Int32[] result, [CallerMemberName]
                 {
                     if (result[i] != ((i < 2) ? (int)firstOp[i] : 0))
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Sse2)}.{nameof(Sse2.ConvertToVector128Int32WithTruncation)}<Int32>(Vector128<Double>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"  firstOp: ({string.Join(", ", firstOp)})");
                 TestLibrary.TestFramework.LogInformation($"   result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/ConvertToVector128Int32WithTruncation.Vector128Single.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/ConvertToVector128Int32WithTruncation.Vector128Single.cs
index cbd788a04267..2b28c6eee7e5 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/ConvertToVector128Int32WithTruncation.Vector128Single.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/ConvertToVector128Int32WithTruncation.Vector128Single.cs
@@ -312,7 +312,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -320,7 +320,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -348,9 +353,11 @@ private void ValidateResult(void* firstOp, void* result, [CallerMemberName] stri
 
         private void ValidateResult(Single[] firstOp, Int32[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (result[0] != (int)firstOp[0])
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -358,18 +365,20 @@ private void ValidateResult(Single[] firstOp, Int32[] result, [CallerMemberName]
                 {
                     if (result[i] != (int)firstOp[i])
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Sse2)}.{nameof(Sse2.ConvertToVector128Int32WithTruncation)}<Int32>(Vector128<Single>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"  firstOp: ({string.Join(", ", firstOp)})");
                 TestLibrary.TestFramework.LogInformation($"   result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/ConvertToVector128Single.Vector128Double.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/ConvertToVector128Single.Vector128Double.cs
index 6f510395b1a9..186574c828f6 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/ConvertToVector128Single.Vector128Double.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/ConvertToVector128Single.Vector128Double.cs
@@ -312,7 +312,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -320,7 +320,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -348,9 +353,11 @@ private void ValidateResult(void* firstOp, void* result, [CallerMemberName] stri
 
         private void ValidateResult(Double[] firstOp, Single[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (BitConverter.SingleToInt32Bits(result[0]) != BitConverter.SingleToInt32Bits((float)firstOp[0]))
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -358,18 +365,20 @@ private void ValidateResult(Double[] firstOp, Single[] result, [CallerMemberName
                 {
                     if (BitConverter.SingleToInt32Bits(result[i]) != ((i < 2) ? BitConverter.SingleToInt32Bits((float)firstOp[i]) : 0))
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Sse2)}.{nameof(Sse2.ConvertToVector128Single)}<Single>(Vector128<Double>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"  firstOp: ({string.Join(", ", firstOp)})");
                 TestLibrary.TestFramework.LogInformation($"   result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/ConvertToVector128Single.Vector128Int32.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/ConvertToVector128Single.Vector128Int32.cs
index c1b824912f18..33afc005f5e8 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/ConvertToVector128Single.Vector128Int32.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/ConvertToVector128Single.Vector128Int32.cs
@@ -312,7 +312,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -320,7 +320,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -348,9 +353,11 @@ private void ValidateResult(void* firstOp, void* result, [CallerMemberName] stri
 
         private void ValidateResult(Int32[] firstOp, Single[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (BitConverter.SingleToInt32Bits(result[0]) != BitConverter.SingleToInt32Bits((float)firstOp[0]))
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -358,18 +365,20 @@ private void ValidateResult(Int32[] firstOp, Single[] result, [CallerMemberName]
                 {
                     if (BitConverter.SingleToInt32Bits(result[i]) != BitConverter.SingleToInt32Bits((float)firstOp[i]))
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Sse2)}.{nameof(Sse2.ConvertToVector128Single)}<Single>(Vector128<Int32>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"  firstOp: ({string.Join(", ", firstOp)})");
                 TestLibrary.TestFramework.LogInformation($"   result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/Divide.Double.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/Divide.Double.cs
index 96e00c175e12..1eb7c0d85229 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/Divide.Double.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/Divide.Double.cs
@@ -334,7 +334,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -342,7 +342,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -374,9 +379,11 @@ private void ValidateResult(void* left, void* right, void* result, [CallerMember
 
         private void ValidateResult(Double[] left, Double[] right, Double[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (BitConverter.DoubleToInt64Bits(left[0] / right[0]) != BitConverter.DoubleToInt64Bits(result[0]))
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -384,19 +391,21 @@ private void ValidateResult(Double[] left, Double[] right, Double[] result, [Cal
                 {
                     if (BitConverter.DoubleToInt64Bits(left[i] / right[i]) != BitConverter.DoubleToInt64Bits(result[i]))
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Sse2)}.{nameof(Sse2.Divide)}<Double>(Vector128<Double>, Vector128<Double>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/DivideScalar.Double.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/DivideScalar.Double.cs
index e5203f5332fd..99fee10d3c73 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/DivideScalar.Double.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/DivideScalar.Double.cs
@@ -334,7 +334,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -342,7 +342,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -374,9 +379,11 @@ private void ValidateResult(void* left, void* right, void* result, [CallerMember
 
         private void ValidateResult(Double[] left, Double[] right, Double[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (BitConverter.DoubleToInt64Bits(left[0] / right[0]) != BitConverter.DoubleToInt64Bits(result[0]))
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -384,19 +391,21 @@ private void ValidateResult(Double[] left, Double[] right, Double[] result, [Cal
                 {
                     if (BitConverter.DoubleToInt64Bits(left[i]) != BitConverter.DoubleToInt64Bits(result[i]))
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Sse2)}.{nameof(Sse2.DivideScalar)}<Double>(Vector128<Double>, Vector128<Double>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/Extract.UInt16.1.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/Extract.UInt16.1.cs
index 5391bbdaaf83..675f6c5457f1 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/Extract.UInt16.1.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/Extract.UInt16.1.cs
@@ -319,7 +319,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -327,7 +327,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -355,17 +360,21 @@ private void ValidateResult(void* firstOp, void* result, [CallerMemberName] stri
 
         private void ValidateResult(UInt16[] firstOp, UInt16[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if ((result[0] != firstOp[1]))
             {
-                Succeeded = false;
+                succeeded = false;
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Sse2)}.{nameof(Sse2.Extract)}<UInt16>(Vector128<UInt16><9>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"  firstOp: ({string.Join(", ", firstOp)})");
                 TestLibrary.TestFramework.LogInformation($"   result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/Extract.UInt16.129.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/Extract.UInt16.129.cs
index 77669cfe3b16..c384be7fc53f 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/Extract.UInt16.129.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/Extract.UInt16.129.cs
@@ -319,7 +319,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -327,7 +327,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -355,17 +360,21 @@ private void ValidateResult(void* firstOp, void* result, [CallerMemberName] stri
 
         private void ValidateResult(UInt16[] firstOp, UInt16[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if ((result[0] != firstOp[1]))
             {
-                Succeeded = false;
+                succeeded = false;
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Sse2)}.{nameof(Sse2.Extract)}<UInt16>(Vector128<UInt16><9>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"  firstOp: ({string.Join(", ", firstOp)})");
                 TestLibrary.TestFramework.LogInformation($"   result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/Insert.Int16.1.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/Insert.Int16.1.cs
index 7a3b2af43345..ba1e3bc30e59 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/Insert.Int16.1.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/Insert.Int16.1.cs
@@ -326,7 +326,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -334,7 +334,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -362,22 +367,25 @@ private void ValidateResult(void* firstOp, void* result, [CallerMemberName] stri
 
         private void ValidateResult(Int16[] firstOp, Int16[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
 
             for (var i = 0; i < RetElementCount; i++)
             {
                 if ((i == 1 ? result[i] != 2 : result[i] != 0))
                 {
-                    Succeeded = false;
+                    succeeded = false;
                     break;
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Sse2)}.{nameof(Sse2.Insert)}<Int16>(Vector128<Int16><9>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"  firstOp: ({string.Join(", ", firstOp)})");
                 TestLibrary.TestFramework.LogInformation($"   result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/Insert.Int16.129.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/Insert.Int16.129.cs
index 8741db933adf..2d8debf00161 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/Insert.Int16.129.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/Insert.Int16.129.cs
@@ -326,7 +326,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -334,7 +334,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -362,22 +367,25 @@ private void ValidateResult(void* firstOp, void* result, [CallerMemberName] stri
 
         private void ValidateResult(Int16[] firstOp, Int16[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
 
             for (var i = 0; i < RetElementCount; i++)
             {
                 if ((i == 1 ? result[i] != 2 : result[i] != 0))
                 {
-                    Succeeded = false;
+                    succeeded = false;
                     break;
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Sse2)}.{nameof(Sse2.Insert)}<Int16>(Vector128<Int16><9>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"  firstOp: ({string.Join(", ", firstOp)})");
                 TestLibrary.TestFramework.LogInformation($"   result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/Insert.UInt16.1.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/Insert.UInt16.1.cs
index 9e105f5a5d8a..ddb1907e70eb 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/Insert.UInt16.1.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/Insert.UInt16.1.cs
@@ -326,7 +326,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -334,7 +334,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -362,22 +367,25 @@ private void ValidateResult(void* firstOp, void* result, [CallerMemberName] stri
 
         private void ValidateResult(UInt16[] firstOp, UInt16[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
 
             for (var i = 0; i < RetElementCount; i++)
             {
                 if ((i == 1 ? result[i] != 2 : result[i] != 0))
                 {
-                    Succeeded = false;
+                    succeeded = false;
                     break;
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Sse2)}.{nameof(Sse2.Insert)}<UInt16>(Vector128<UInt16><9>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"  firstOp: ({string.Join(", ", firstOp)})");
                 TestLibrary.TestFramework.LogInformation($"   result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/Insert.UInt16.129.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/Insert.UInt16.129.cs
index afc53688bf89..6cadb11f8cd0 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/Insert.UInt16.129.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/Insert.UInt16.129.cs
@@ -326,7 +326,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -334,7 +334,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -362,22 +367,25 @@ private void ValidateResult(void* firstOp, void* result, [CallerMemberName] stri
 
         private void ValidateResult(UInt16[] firstOp, UInt16[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
 
             for (var i = 0; i < RetElementCount; i++)
             {
                 if ((i == 1 ? result[i] != 2 : result[i] != 0))
                 {
-                    Succeeded = false;
+                    succeeded = false;
                     break;
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Sse2)}.{nameof(Sse2.Insert)}<UInt16>(Vector128<UInt16><9>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"  firstOp: ({string.Join(", ", firstOp)})");
                 TestLibrary.TestFramework.LogInformation($"   result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/LoadScalarVector128.Double.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/LoadScalarVector128.Double.cs
index b7d43216c9d5..cd69e0d1c3e2 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/LoadScalarVector128.Double.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/LoadScalarVector128.Double.cs
@@ -133,9 +133,11 @@ private void ValidateResult(void* firstOp, void* result, [CallerMemberName] stri
 
         private void ValidateResult(Double[] firstOp, Double[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (BitConverter.DoubleToInt64Bits(firstOp[0]) != BitConverter.DoubleToInt64Bits(result[0]))
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -143,18 +145,20 @@ private void ValidateResult(Double[] firstOp, Double[] result, [CallerMemberName
                 {
                     if (0 != BitConverter.DoubleToInt64Bits(result[i]))
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Sse2)}.{nameof(Sse2.LoadScalarVector128)}<Double>(Vector128<Double>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"  firstOp: ({string.Join(", ", firstOp)})");
                 TestLibrary.TestFramework.LogInformation($"   result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/LoadScalarVector128.Int32.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/LoadScalarVector128.Int32.cs
index 7fa1e2042bfc..b4360b3982d9 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/LoadScalarVector128.Int32.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/LoadScalarVector128.Int32.cs
@@ -133,9 +133,11 @@ private void ValidateResult(void* firstOp, void* result, [CallerMemberName] stri
 
         private void ValidateResult(Int32[] firstOp, Int32[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (firstOp[0] != result[0])
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -143,18 +145,20 @@ private void ValidateResult(Int32[] firstOp, Int32[] result, [CallerMemberName]
                 {
                     if (0 != result[i])
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Sse2)}.{nameof(Sse2.LoadScalarVector128)}<Int32>(Vector128<Int32>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"  firstOp: ({string.Join(", ", firstOp)})");
                 TestLibrary.TestFramework.LogInformation($"   result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/LoadScalarVector128.Int64.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/LoadScalarVector128.Int64.cs
index 9f83a6f5a12f..a5ab5303eca7 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/LoadScalarVector128.Int64.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/LoadScalarVector128.Int64.cs
@@ -133,9 +133,11 @@ private void ValidateResult(void* firstOp, void* result, [CallerMemberName] stri
 
         private void ValidateResult(Int64[] firstOp, Int64[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (firstOp[0] != result[0])
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -143,18 +145,20 @@ private void ValidateResult(Int64[] firstOp, Int64[] result, [CallerMemberName]
                 {
                     if (0 != result[i])
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Sse2)}.{nameof(Sse2.LoadScalarVector128)}<Int64>(Vector128<Int64>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"  firstOp: ({string.Join(", ", firstOp)})");
                 TestLibrary.TestFramework.LogInformation($"   result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/LoadScalarVector128.UInt32.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/LoadScalarVector128.UInt32.cs
index 9ecccd23b113..1c8939de681c 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/LoadScalarVector128.UInt32.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/LoadScalarVector128.UInt32.cs
@@ -133,9 +133,11 @@ private void ValidateResult(void* firstOp, void* result, [CallerMemberName] stri
 
         private void ValidateResult(UInt32[] firstOp, UInt32[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (firstOp[0] != result[0])
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -143,18 +145,20 @@ private void ValidateResult(UInt32[] firstOp, UInt32[] result, [CallerMemberName
                 {
                     if (0 != result[i])
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Sse2)}.{nameof(Sse2.LoadScalarVector128)}<UInt32>(Vector128<UInt32>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"  firstOp: ({string.Join(", ", firstOp)})");
                 TestLibrary.TestFramework.LogInformation($"   result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/LoadScalarVector128.UInt64.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/LoadScalarVector128.UInt64.cs
index 072a9825bb38..caef29575ec3 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/LoadScalarVector128.UInt64.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/LoadScalarVector128.UInt64.cs
@@ -133,9 +133,11 @@ private void ValidateResult(void* firstOp, void* result, [CallerMemberName] stri
 
         private void ValidateResult(UInt64[] firstOp, UInt64[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (firstOp[0] != result[0])
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -143,18 +145,20 @@ private void ValidateResult(UInt64[] firstOp, UInt64[] result, [CallerMemberName
                 {
                     if (0 != result[i])
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Sse2)}.{nameof(Sse2.LoadScalarVector128)}<UInt64>(Vector128<UInt64>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"  firstOp: ({string.Join(", ", firstOp)})");
                 TestLibrary.TestFramework.LogInformation($"   result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/LoadVector128.Byte.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/LoadVector128.Byte.cs
index 07de871f2e59..dcd3d67ea684 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/LoadVector128.Byte.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/LoadVector128.Byte.cs
@@ -133,9 +133,11 @@ private void ValidateResult(void* firstOp, void* result, [CallerMemberName] stri
 
         private void ValidateResult(Byte[] firstOp, Byte[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (firstOp[0] != result[0])
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -143,18 +145,20 @@ private void ValidateResult(Byte[] firstOp, Byte[] result, [CallerMemberName] st
                 {
                     if (firstOp[i] != result[i])
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Sse2)}.{nameof(Sse2.LoadVector128)}<Byte>(Vector128<Byte>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"  firstOp: ({string.Join(", ", firstOp)})");
                 TestLibrary.TestFramework.LogInformation($"   result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/LoadVector128.Double.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/LoadVector128.Double.cs
index 820aba9bba0b..37eea7676919 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/LoadVector128.Double.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/LoadVector128.Double.cs
@@ -133,9 +133,11 @@ private void ValidateResult(void* firstOp, void* result, [CallerMemberName] stri
 
         private void ValidateResult(Double[] firstOp, Double[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (BitConverter.DoubleToInt64Bits(firstOp[0]) != BitConverter.DoubleToInt64Bits(result[0]))
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -143,18 +145,20 @@ private void ValidateResult(Double[] firstOp, Double[] result, [CallerMemberName
                 {
                     if (BitConverter.DoubleToInt64Bits(firstOp[i]) != BitConverter.DoubleToInt64Bits(result[i]))
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Sse2)}.{nameof(Sse2.LoadVector128)}<Double>(Vector128<Double>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"  firstOp: ({string.Join(", ", firstOp)})");
                 TestLibrary.TestFramework.LogInformation($"   result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/LoadVector128.Int16.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/LoadVector128.Int16.cs
index b280aa5fd93e..a93f8ebe6b7a 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/LoadVector128.Int16.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/LoadVector128.Int16.cs
@@ -133,9 +133,11 @@ private void ValidateResult(void* firstOp, void* result, [CallerMemberName] stri
 
         private void ValidateResult(Int16[] firstOp, Int16[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (firstOp[0] != result[0])
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -143,18 +145,20 @@ private void ValidateResult(Int16[] firstOp, Int16[] result, [CallerMemberName]
                 {
                     if (firstOp[i] != result[i])
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Sse2)}.{nameof(Sse2.LoadVector128)}<Int16>(Vector128<Int16>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"  firstOp: ({string.Join(", ", firstOp)})");
                 TestLibrary.TestFramework.LogInformation($"   result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/LoadVector128.Int32.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/LoadVector128.Int32.cs
index 9118b24061f5..5466ab5fcc6a 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/LoadVector128.Int32.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/LoadVector128.Int32.cs
@@ -133,9 +133,11 @@ private void ValidateResult(void* firstOp, void* result, [CallerMemberName] stri
 
         private void ValidateResult(Int32[] firstOp, Int32[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (firstOp[0] != result[0])
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -143,18 +145,20 @@ private void ValidateResult(Int32[] firstOp, Int32[] result, [CallerMemberName]
                 {
                     if (firstOp[i] != result[i])
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Sse2)}.{nameof(Sse2.LoadVector128)}<Int32>(Vector128<Int32>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"  firstOp: ({string.Join(", ", firstOp)})");
                 TestLibrary.TestFramework.LogInformation($"   result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/LoadVector128.Int64.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/LoadVector128.Int64.cs
index a953f2a29de0..365f9f263313 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/LoadVector128.Int64.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/LoadVector128.Int64.cs
@@ -133,9 +133,11 @@ private void ValidateResult(void* firstOp, void* result, [CallerMemberName] stri
 
         private void ValidateResult(Int64[] firstOp, Int64[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (firstOp[0] != result[0])
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -143,18 +145,20 @@ private void ValidateResult(Int64[] firstOp, Int64[] result, [CallerMemberName]
                 {
                     if (firstOp[i] != result[i])
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Sse2)}.{nameof(Sse2.LoadVector128)}<Int64>(Vector128<Int64>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"  firstOp: ({string.Join(", ", firstOp)})");
                 TestLibrary.TestFramework.LogInformation($"   result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/LoadVector128.SByte.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/LoadVector128.SByte.cs
index 09b7e99c17b7..0b1f138a4225 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/LoadVector128.SByte.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/LoadVector128.SByte.cs
@@ -133,9 +133,11 @@ private void ValidateResult(void* firstOp, void* result, [CallerMemberName] stri
 
         private void ValidateResult(SByte[] firstOp, SByte[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (firstOp[0] != result[0])
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -143,18 +145,20 @@ private void ValidateResult(SByte[] firstOp, SByte[] result, [CallerMemberName]
                 {
                     if (firstOp[i] != result[i])
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Sse2)}.{nameof(Sse2.LoadVector128)}<SByte>(Vector128<SByte>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"  firstOp: ({string.Join(", ", firstOp)})");
                 TestLibrary.TestFramework.LogInformation($"   result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/LoadVector128.UInt16.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/LoadVector128.UInt16.cs
index af2e6359324f..4d4502a690b0 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/LoadVector128.UInt16.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/LoadVector128.UInt16.cs
@@ -133,9 +133,11 @@ private void ValidateResult(void* firstOp, void* result, [CallerMemberName] stri
 
         private void ValidateResult(UInt16[] firstOp, UInt16[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (firstOp[0] != result[0])
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -143,18 +145,20 @@ private void ValidateResult(UInt16[] firstOp, UInt16[] result, [CallerMemberName
                 {
                     if (firstOp[i] != result[i])
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Sse2)}.{nameof(Sse2.LoadVector128)}<UInt16>(Vector128<UInt16>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"  firstOp: ({string.Join(", ", firstOp)})");
                 TestLibrary.TestFramework.LogInformation($"   result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/LoadVector128.UInt32.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/LoadVector128.UInt32.cs
index 9274b53429be..e086f2db59a7 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/LoadVector128.UInt32.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/LoadVector128.UInt32.cs
@@ -133,9 +133,11 @@ private void ValidateResult(void* firstOp, void* result, [CallerMemberName] stri
 
         private void ValidateResult(UInt32[] firstOp, UInt32[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (firstOp[0] != result[0])
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -143,18 +145,20 @@ private void ValidateResult(UInt32[] firstOp, UInt32[] result, [CallerMemberName
                 {
                     if (firstOp[i] != result[i])
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Sse2)}.{nameof(Sse2.LoadVector128)}<UInt32>(Vector128<UInt32>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"  firstOp: ({string.Join(", ", firstOp)})");
                 TestLibrary.TestFramework.LogInformation($"   result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/LoadVector128.UInt64.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/LoadVector128.UInt64.cs
index 6f99db2c945c..b64cf3aca9e4 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/LoadVector128.UInt64.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/LoadVector128.UInt64.cs
@@ -133,9 +133,11 @@ private void ValidateResult(void* firstOp, void* result, [CallerMemberName] stri
 
         private void ValidateResult(UInt64[] firstOp, UInt64[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (firstOp[0] != result[0])
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -143,18 +145,20 @@ private void ValidateResult(UInt64[] firstOp, UInt64[] result, [CallerMemberName
                 {
                     if (firstOp[i] != result[i])
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Sse2)}.{nameof(Sse2.LoadVector128)}<UInt64>(Vector128<UInt64>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"  firstOp: ({string.Join(", ", firstOp)})");
                 TestLibrary.TestFramework.LogInformation($"   result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/Max.Byte.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/Max.Byte.cs
index bd7cc51328b0..5899defde281 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/Max.Byte.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/Max.Byte.cs
@@ -334,7 +334,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -342,7 +342,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -374,9 +379,11 @@ private void ValidateResult(void* left, void* right, void* result, [CallerMember
 
         private void ValidateResult(Byte[] left, Byte[] right, Byte[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (Math.Max(left[0], right[0]) != result[0])
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -384,19 +391,21 @@ private void ValidateResult(Byte[] left, Byte[] right, Byte[] result, [CallerMem
                 {
                     if (Math.Max(left[i], right[i]) != result[i])
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Sse2)}.{nameof(Sse2.Max)}<Byte>(Vector128<Byte>, Vector128<Byte>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/Max.Double.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/Max.Double.cs
index 821376a3d1ec..55f284bf79fd 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/Max.Double.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/Max.Double.cs
@@ -334,7 +334,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -342,7 +342,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -374,9 +379,11 @@ private void ValidateResult(void* left, void* right, void* result, [CallerMember
 
         private void ValidateResult(Double[] left, Double[] right, Double[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (BitConverter.DoubleToInt64Bits(Math.Max(left[0], right[0])) != BitConverter.DoubleToInt64Bits(result[0]))
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -384,19 +391,21 @@ private void ValidateResult(Double[] left, Double[] right, Double[] result, [Cal
                 {
                     if (BitConverter.DoubleToInt64Bits(Math.Max(left[i], right[i])) != BitConverter.DoubleToInt64Bits(result[i]))
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Sse2)}.{nameof(Sse2.Max)}<Double>(Vector128<Double>, Vector128<Double>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/Max.Int16.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/Max.Int16.cs
index c0a08d7e7255..3c72d97ca3d2 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/Max.Int16.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/Max.Int16.cs
@@ -334,7 +334,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -342,7 +342,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -374,9 +379,11 @@ private void ValidateResult(void* left, void* right, void* result, [CallerMember
 
         private void ValidateResult(Int16[] left, Int16[] right, Int16[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (Math.Max(left[0], right[0]) != result[0])
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -384,19 +391,21 @@ private void ValidateResult(Int16[] left, Int16[] right, Int16[] result, [Caller
                 {
                     if (Math.Max(left[i], right[i]) != result[i])
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Sse2)}.{nameof(Sse2.Max)}<Int16>(Vector128<Int16>, Vector128<Int16>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/MaxScalar.Double.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/MaxScalar.Double.cs
index 90b776da7dd1..fb9c7df2ad54 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/MaxScalar.Double.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/MaxScalar.Double.cs
@@ -334,7 +334,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -342,7 +342,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -374,9 +379,11 @@ private void ValidateResult(void* left, void* right, void* result, [CallerMember
 
         private void ValidateResult(Double[] left, Double[] right, Double[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (BitConverter.DoubleToInt64Bits(Math.Max(left[0], right[0])) != BitConverter.DoubleToInt64Bits(result[0]))
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -384,19 +391,21 @@ private void ValidateResult(Double[] left, Double[] right, Double[] result, [Cal
                 {
                     if (BitConverter.DoubleToInt64Bits(left[i]) != BitConverter.DoubleToInt64Bits(result[i]))
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Sse2)}.{nameof(Sse2.MaxScalar)}<Double>(Vector128<Double>, Vector128<Double>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/Min.Byte.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/Min.Byte.cs
index b2d1d4b8f413..84ef084eb689 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/Min.Byte.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/Min.Byte.cs
@@ -334,7 +334,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -342,7 +342,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -374,9 +379,11 @@ private void ValidateResult(void* left, void* right, void* result, [CallerMember
 
         private void ValidateResult(Byte[] left, Byte[] right, Byte[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (Math.Min(left[0], right[0]) != result[0])
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -384,19 +391,21 @@ private void ValidateResult(Byte[] left, Byte[] right, Byte[] result, [CallerMem
                 {
                     if (Math.Min(left[i], right[i]) != result[i])
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Sse2)}.{nameof(Sse2.Min)}<Byte>(Vector128<Byte>, Vector128<Byte>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/Min.Double.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/Min.Double.cs
index 8e72d20b6e9d..05969acd2335 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/Min.Double.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/Min.Double.cs
@@ -334,7 +334,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -342,7 +342,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -374,9 +379,11 @@ private void ValidateResult(void* left, void* right, void* result, [CallerMember
 
         private void ValidateResult(Double[] left, Double[] right, Double[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (BitConverter.DoubleToInt64Bits(Math.Min(left[0], right[0])) != BitConverter.DoubleToInt64Bits(result[0]))
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -384,19 +391,21 @@ private void ValidateResult(Double[] left, Double[] right, Double[] result, [Cal
                 {
                     if (BitConverter.DoubleToInt64Bits(Math.Min(left[i], right[i])) != BitConverter.DoubleToInt64Bits(result[i]))
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Sse2)}.{nameof(Sse2.Min)}<Double>(Vector128<Double>, Vector128<Double>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/Min.Int16.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/Min.Int16.cs
index 89e2d3e503bd..f48e07ce5bb1 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/Min.Int16.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/Min.Int16.cs
@@ -334,7 +334,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -342,7 +342,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -374,9 +379,11 @@ private void ValidateResult(void* left, void* right, void* result, [CallerMember
 
         private void ValidateResult(Int16[] left, Int16[] right, Int16[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (Math.Min(left[0], right[0]) != result[0])
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -384,19 +391,21 @@ private void ValidateResult(Int16[] left, Int16[] right, Int16[] result, [Caller
                 {
                     if (Math.Min(left[i], right[i]) != result[i])
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Sse2)}.{nameof(Sse2.Min)}<Int16>(Vector128<Int16>, Vector128<Int16>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/MinScalar.Double.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/MinScalar.Double.cs
index d391ceeeff0b..27c080676ba5 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/MinScalar.Double.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/MinScalar.Double.cs
@@ -334,7 +334,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -342,7 +342,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -374,9 +379,11 @@ private void ValidateResult(void* left, void* right, void* result, [CallerMember
 
         private void ValidateResult(Double[] left, Double[] right, Double[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (BitConverter.DoubleToInt64Bits(Math.Min(left[0], right[0])) != BitConverter.DoubleToInt64Bits(result[0]))
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -384,19 +391,21 @@ private void ValidateResult(Double[] left, Double[] right, Double[] result, [Cal
                 {
                     if (BitConverter.DoubleToInt64Bits(left[i]) != BitConverter.DoubleToInt64Bits(result[i]))
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Sse2)}.{nameof(Sse2.MinScalar)}<Double>(Vector128<Double>, Vector128<Double>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/Multiply.Double.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/Multiply.Double.cs
index 46008a34f9bd..3b6dc9fb0223 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/Multiply.Double.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/Multiply.Double.cs
@@ -334,7 +334,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -342,7 +342,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -374,9 +379,11 @@ private void ValidateResult(void* left, void* right, void* result, [CallerMember
 
         private void ValidateResult(Double[] left, Double[] right, Double[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (BitConverter.DoubleToInt64Bits(left[0] * right[0]) != BitConverter.DoubleToInt64Bits(result[0]))
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -384,19 +391,21 @@ private void ValidateResult(Double[] left, Double[] right, Double[] result, [Cal
                 {
                     if (BitConverter.DoubleToInt64Bits(left[i] * right[i]) != BitConverter.DoubleToInt64Bits(result[i]))
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Sse2)}.{nameof(Sse2.Multiply)}<Double>(Vector128<Double>, Vector128<Double>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/MultiplyAddAdjacent.Int32.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/MultiplyAddAdjacent.Int32.cs
index 49dd651d7533..6ed768502824 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/MultiplyAddAdjacent.Int32.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/MultiplyAddAdjacent.Int32.cs
@@ -334,7 +334,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -342,7 +342,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -374,9 +379,11 @@ private void ValidateResult(void* left, void* right, void* result, [CallerMember
 
         private void ValidateResult(Int16[] left, Int16[] right, Int32[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (result[0] != Math.Clamp(((right[1] * left[1]) + (right[0] * left[0])), int.MinValue, int.MaxValue))
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -384,19 +391,21 @@ private void ValidateResult(Int16[] left, Int16[] right, Int32[] result, [Caller
                 {
                     if (result[i] != Math.Clamp(((right[(i * 2) + 1] * left[(i * 2) + 1]) + (right[i * 2] * left[i * 2])), int.MinValue, int.MaxValue))
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Sse2)}.{nameof(Sse2.MultiplyAddAdjacent)}<Int32>(Vector128<Int16>, Vector128<Int16>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/MultiplyLow.Int16.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/MultiplyLow.Int16.cs
index 372a39cef1eb..0e923840644c 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/MultiplyLow.Int16.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/MultiplyLow.Int16.cs
@@ -334,7 +334,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -342,7 +342,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -374,9 +379,11 @@ private void ValidateResult(void* left, void* right, void* result, [CallerMember
 
         private void ValidateResult(Int16[] left, Int16[] right, Int16[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (result[0] != BitConverter.ToInt16(BitConverter.GetBytes(((int)(left[0])) * right[0]), 0))
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -384,19 +391,21 @@ private void ValidateResult(Int16[] left, Int16[] right, Int16[] result, [Caller
                 {
                     if (result[i] != BitConverter.ToInt16(BitConverter.GetBytes(((int)(left[i])) * right[i]), 0))
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Sse2)}.{nameof(Sse2.MultiplyLow)}<Int16>(Vector128<Int16>, Vector128<Int16>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/MultiplyLow.UInt16.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/MultiplyLow.UInt16.cs
index 114e920b4f69..5b3d43b01f79 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/MultiplyLow.UInt16.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/MultiplyLow.UInt16.cs
@@ -334,7 +334,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -342,7 +342,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -374,9 +379,11 @@ private void ValidateResult(void* left, void* right, void* result, [CallerMember
 
         private void ValidateResult(UInt16[] left, UInt16[] right, UInt16[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (result[0] != BitConverter.ToUInt16(BitConverter.GetBytes(((uint)(left[0])) * right[0]), 0))
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -384,19 +391,21 @@ private void ValidateResult(UInt16[] left, UInt16[] right, UInt16[] result, [Cal
                 {
                     if (result[i] != BitConverter.ToUInt16(BitConverter.GetBytes(((uint)(left[i])) * right[i]), 0))
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Sse2)}.{nameof(Sse2.MultiplyLow)}<UInt16>(Vector128<UInt16>, Vector128<UInt16>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/MultiplyScalar.Double.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/MultiplyScalar.Double.cs
index 104eb932d98a..6aae6dbbda41 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/MultiplyScalar.Double.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/MultiplyScalar.Double.cs
@@ -334,7 +334,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -342,7 +342,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -374,9 +379,11 @@ private void ValidateResult(void* left, void* right, void* result, [CallerMember
 
         private void ValidateResult(Double[] left, Double[] right, Double[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (BitConverter.DoubleToInt64Bits(left[0] * right[0]) != BitConverter.DoubleToInt64Bits(result[0]))
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -384,19 +391,21 @@ private void ValidateResult(Double[] left, Double[] right, Double[] result, [Cal
                 {
                     if (BitConverter.DoubleToInt64Bits(left[i]) != BitConverter.DoubleToInt64Bits(result[i]))
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Sse2)}.{nameof(Sse2.MultiplyScalar)}<Double>(Vector128<Double>, Vector128<Double>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/Or.Byte.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/Or.Byte.cs
index 62a9e6dcb5b1..77e43f2adbaa 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/Or.Byte.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/Or.Byte.cs
@@ -334,7 +334,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -342,7 +342,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -374,9 +379,11 @@ private void ValidateResult(void* left, void* right, void* result, [CallerMember
 
         private void ValidateResult(Byte[] left, Byte[] right, Byte[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if ((byte)(left[0] | right[0]) != result[0])
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -384,19 +391,21 @@ private void ValidateResult(Byte[] left, Byte[] right, Byte[] result, [CallerMem
                 {
                     if ((byte)(left[i] | right[i]) != result[i])
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Sse2)}.{nameof(Sse2.Or)}<Byte>(Vector128<Byte>, Vector128<Byte>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/Or.Double.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/Or.Double.cs
index c6ba468e8e47..2f353bd9a23b 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/Or.Double.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/Or.Double.cs
@@ -334,7 +334,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -342,7 +342,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -374,9 +379,11 @@ private void ValidateResult(void* left, void* right, void* result, [CallerMember
 
         private void ValidateResult(Double[] left, Double[] right, Double[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if ((BitConverter.DoubleToInt64Bits(left[0]) | BitConverter.DoubleToInt64Bits(right[0])) != BitConverter.DoubleToInt64Bits(result[0]))
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -384,19 +391,21 @@ private void ValidateResult(Double[] left, Double[] right, Double[] result, [Cal
                 {
                     if ((BitConverter.DoubleToInt64Bits(left[i]) | BitConverter.DoubleToInt64Bits(right[i])) != BitConverter.DoubleToInt64Bits(result[i]))
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Sse2)}.{nameof(Sse2.Or)}<Double>(Vector128<Double>, Vector128<Double>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/Or.Int16.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/Or.Int16.cs
index 28b5033fecc3..094877cf82bd 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/Or.Int16.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/Or.Int16.cs
@@ -334,7 +334,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -342,7 +342,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -374,9 +379,11 @@ private void ValidateResult(void* left, void* right, void* result, [CallerMember
 
         private void ValidateResult(Int16[] left, Int16[] right, Int16[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if ((short)(left[0] | right[0]) != result[0])
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -384,19 +391,21 @@ private void ValidateResult(Int16[] left, Int16[] right, Int16[] result, [Caller
                 {
                     if ((short)(left[i] | right[i]) != result[i])
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Sse2)}.{nameof(Sse2.Or)}<Int16>(Vector128<Int16>, Vector128<Int16>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/Or.Int32.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/Or.Int32.cs
index 0fa0516376f1..58604fb694e7 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/Or.Int32.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/Or.Int32.cs
@@ -334,7 +334,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -342,7 +342,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -374,9 +379,11 @@ private void ValidateResult(void* left, void* right, void* result, [CallerMember
 
         private void ValidateResult(Int32[] left, Int32[] right, Int32[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if ((int)(left[0] | right[0]) != result[0])
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -384,19 +391,21 @@ private void ValidateResult(Int32[] left, Int32[] right, Int32[] result, [Caller
                 {
                     if ((int)(left[i] | right[i]) != result[i])
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Sse2)}.{nameof(Sse2.Or)}<Int32>(Vector128<Int32>, Vector128<Int32>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/Or.Int64.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/Or.Int64.cs
index 54863530d3c8..c921e044a4c0 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/Or.Int64.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/Or.Int64.cs
@@ -334,7 +334,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -342,7 +342,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -374,9 +379,11 @@ private void ValidateResult(void* left, void* right, void* result, [CallerMember
 
         private void ValidateResult(Int64[] left, Int64[] right, Int64[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if ((long)(left[0] | right[0]) != result[0])
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -384,19 +391,21 @@ private void ValidateResult(Int64[] left, Int64[] right, Int64[] result, [Caller
                 {
                     if ((long)(left[i] | right[i]) != result[i])
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Sse2)}.{nameof(Sse2.Or)}<Int64>(Vector128<Int64>, Vector128<Int64>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/Or.SByte.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/Or.SByte.cs
index 2cb83a6ddb9d..00e85072b4d7 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/Or.SByte.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/Or.SByte.cs
@@ -334,7 +334,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -342,7 +342,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -374,9 +379,11 @@ private void ValidateResult(void* left, void* right, void* result, [CallerMember
 
         private void ValidateResult(SByte[] left, SByte[] right, SByte[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if ((sbyte)(left[0] | right[0]) != result[0])
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -384,19 +391,21 @@ private void ValidateResult(SByte[] left, SByte[] right, SByte[] result, [Caller
                 {
                     if ((sbyte)(left[i] | right[i]) != result[i])
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Sse2)}.{nameof(Sse2.Or)}<SByte>(Vector128<SByte>, Vector128<SByte>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/Or.UInt16.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/Or.UInt16.cs
index fa654a1cfb79..90cfcfcffa55 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/Or.UInt16.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/Or.UInt16.cs
@@ -334,7 +334,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -342,7 +342,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -374,9 +379,11 @@ private void ValidateResult(void* left, void* right, void* result, [CallerMember
 
         private void ValidateResult(UInt16[] left, UInt16[] right, UInt16[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if ((ushort)(left[0] | right[0]) != result[0])
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -384,19 +391,21 @@ private void ValidateResult(UInt16[] left, UInt16[] right, UInt16[] result, [Cal
                 {
                     if ((ushort)(left[i] | right[i]) != result[i])
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Sse2)}.{nameof(Sse2.Or)}<UInt16>(Vector128<UInt16>, Vector128<UInt16>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/Or.UInt32.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/Or.UInt32.cs
index 107955746520..f686dde136c4 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/Or.UInt32.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/Or.UInt32.cs
@@ -334,7 +334,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -342,7 +342,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -374,9 +379,11 @@ private void ValidateResult(void* left, void* right, void* result, [CallerMember
 
         private void ValidateResult(UInt32[] left, UInt32[] right, UInt32[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if ((uint)(left[0] | right[0]) != result[0])
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -384,19 +391,21 @@ private void ValidateResult(UInt32[] left, UInt32[] right, UInt32[] result, [Cal
                 {
                     if ((uint)(left[i] | right[i]) != result[i])
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Sse2)}.{nameof(Sse2.Or)}<UInt32>(Vector128<UInt32>, Vector128<UInt32>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/Or.UInt64.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/Or.UInt64.cs
index 7fe77056bbef..21e3286d0034 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/Or.UInt64.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/Or.UInt64.cs
@@ -334,7 +334,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -342,7 +342,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -374,9 +379,11 @@ private void ValidateResult(void* left, void* right, void* result, [CallerMember
 
         private void ValidateResult(UInt64[] left, UInt64[] right, UInt64[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if ((ulong)(left[0] | right[0]) != result[0])
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -384,19 +391,21 @@ private void ValidateResult(UInt64[] left, UInt64[] right, UInt64[] result, [Cal
                 {
                     if ((ulong)(left[i] | right[i]) != result[i])
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Sse2)}.{nameof(Sse2.Or)}<UInt64>(Vector128<UInt64>, Vector128<UInt64>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/PackSignedSaturate.Int16.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/PackSignedSaturate.Int16.cs
index 02b94e9eef82..5cc368f1b9ae 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/PackSignedSaturate.Int16.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/PackSignedSaturate.Int16.cs
@@ -334,7 +334,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -342,7 +342,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -374,9 +379,11 @@ private void ValidateResult(void* left, void* right, void* result, [CallerMember
 
         private void ValidateResult(Int32[] left, Int32[] right, Int16[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (result[0] != (short)Math.Min(Math.Max(left[0], short.MinValue), short.MaxValue))
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -384,19 +391,21 @@ private void ValidateResult(Int32[] left, Int32[] right, Int16[] result, [Caller
                 {
                     if (result[i] != ((i < 4) ? (short)Math.Min(Math.Max(left[i], short.MinValue), short.MaxValue) : (short)Math.Min(Math.Max(right[i%4], short.MinValue), short.MaxValue)))
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Sse2)}.{nameof(Sse2.PackSignedSaturate)}<Int16>(Vector128<Int32>, Vector128<Int32>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/PackSignedSaturate.SByte.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/PackSignedSaturate.SByte.cs
index 7f0265684235..624df548ea3c 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/PackSignedSaturate.SByte.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/PackSignedSaturate.SByte.cs
@@ -334,7 +334,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -342,7 +342,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -374,9 +379,11 @@ private void ValidateResult(void* left, void* right, void* result, [CallerMember
 
         private void ValidateResult(Int16[] left, Int16[] right, SByte[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (result[0] != (sbyte)Math.Min(Math.Max(left[0], sbyte.MinValue), sbyte.MaxValue))
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -384,19 +391,21 @@ private void ValidateResult(Int16[] left, Int16[] right, SByte[] result, [Caller
                 {
                     if (result[i] != ((i < 8) ? (sbyte)Math.Min(Math.Max(left[i], sbyte.MinValue), sbyte.MaxValue) : (sbyte)Math.Min(Math.Max(right[i%8], sbyte.MinValue), sbyte.MaxValue)))
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Sse2)}.{nameof(Sse2.PackSignedSaturate)}<SByte>(Vector128<Int16>, Vector128<Int16>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/PackUnsignedSaturate.Byte.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/PackUnsignedSaturate.Byte.cs
index 21575637ac32..0bc7635ca19b 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/PackUnsignedSaturate.Byte.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/PackUnsignedSaturate.Byte.cs
@@ -334,7 +334,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -342,7 +342,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -374,9 +379,11 @@ private void ValidateResult(void* left, void* right, void* result, [CallerMember
 
         private void ValidateResult(Int16[] left, Int16[] right, Byte[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (result[0] != (byte)Math.Min(Math.Max(left[0], byte.MinValue), byte.MaxValue))
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -384,19 +391,21 @@ private void ValidateResult(Int16[] left, Int16[] right, Byte[] result, [CallerM
                 {
                     if (result[i] != ((i < 8) ? (byte)Math.Min(Math.Max(left[i], byte.MinValue), byte.MaxValue) : (byte)Math.Min(Math.Max(right[i%8], byte.MinValue), byte.MaxValue)))
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Sse2)}.{nameof(Sse2.PackUnsignedSaturate)}<Byte>(Vector128<Int16>, Vector128<Int16>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/ShiftLeftLogical.Int16.1.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/ShiftLeftLogical.Int16.1.cs
index 78d5b34bb4c3..423e64894081 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/ShiftLeftLogical.Int16.1.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/ShiftLeftLogical.Int16.1.cs
@@ -319,7 +319,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -327,7 +327,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -355,9 +360,11 @@ private void ValidateResult(void* firstOp, void* result, [CallerMemberName] stri
 
         private void ValidateResult(Int16[] firstOp, Int16[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if ((short)(firstOp[0] << 1) != result[0])
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -365,18 +372,20 @@ private void ValidateResult(Int16[] firstOp, Int16[] result, [CallerMemberName]
                 {
                     if ((short)(firstOp[i] << 1) != result[i])
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Sse2)}.{nameof(Sse2.ShiftLeftLogical)}<Int16>(Vector128<Int16><9>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"  firstOp: ({string.Join(", ", firstOp)})");
                 TestLibrary.TestFramework.LogInformation($"   result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/ShiftLeftLogical.Int16.16.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/ShiftLeftLogical.Int16.16.cs
index 237ca7d72a25..e665dc7f3f95 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/ShiftLeftLogical.Int16.16.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/ShiftLeftLogical.Int16.16.cs
@@ -319,7 +319,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -327,7 +327,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -355,9 +360,11 @@ private void ValidateResult(void* firstOp, void* result, [CallerMemberName] stri
 
         private void ValidateResult(Int16[] firstOp, Int16[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (0 != result[0])
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -365,18 +372,20 @@ private void ValidateResult(Int16[] firstOp, Int16[] result, [CallerMemberName]
                 {
                     if (0 != result[i])
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Sse2)}.{nameof(Sse2.ShiftLeftLogical)}<Int16>(Vector128<Int16><9>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"  firstOp: ({string.Join(", ", firstOp)})");
                 TestLibrary.TestFramework.LogInformation($"   result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/ShiftLeftLogical.Int32.1.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/ShiftLeftLogical.Int32.1.cs
index b3c70c502728..f52f10d96e92 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/ShiftLeftLogical.Int32.1.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/ShiftLeftLogical.Int32.1.cs
@@ -319,7 +319,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -327,7 +327,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -355,9 +360,11 @@ private void ValidateResult(void* firstOp, void* result, [CallerMemberName] stri
 
         private void ValidateResult(Int32[] firstOp, Int32[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if ((int)(firstOp[0] << 1) != result[0])
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -365,18 +372,20 @@ private void ValidateResult(Int32[] firstOp, Int32[] result, [CallerMemberName]
                 {
                     if ((int)(firstOp[i] << 1) != result[i])
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Sse2)}.{nameof(Sse2.ShiftLeftLogical)}<Int32>(Vector128<Int32><9>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"  firstOp: ({string.Join(", ", firstOp)})");
                 TestLibrary.TestFramework.LogInformation($"   result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/ShiftLeftLogical.Int32.32.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/ShiftLeftLogical.Int32.32.cs
index 24f74e70571e..5c6da2d815f8 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/ShiftLeftLogical.Int32.32.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/ShiftLeftLogical.Int32.32.cs
@@ -319,7 +319,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -327,7 +327,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -355,9 +360,11 @@ private void ValidateResult(void* firstOp, void* result, [CallerMemberName] stri
 
         private void ValidateResult(Int32[] firstOp, Int32[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (0 != result[0])
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -365,18 +372,20 @@ private void ValidateResult(Int32[] firstOp, Int32[] result, [CallerMemberName]
                 {
                     if (0 != result[i])
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Sse2)}.{nameof(Sse2.ShiftLeftLogical)}<Int32>(Vector128<Int32><9>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"  firstOp: ({string.Join(", ", firstOp)})");
                 TestLibrary.TestFramework.LogInformation($"   result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/ShiftLeftLogical.Int64.1.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/ShiftLeftLogical.Int64.1.cs
index f0747c9207b2..7e768016e406 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/ShiftLeftLogical.Int64.1.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/ShiftLeftLogical.Int64.1.cs
@@ -319,7 +319,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -327,7 +327,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -355,9 +360,11 @@ private void ValidateResult(void* firstOp, void* result, [CallerMemberName] stri
 
         private void ValidateResult(Int64[] firstOp, Int64[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if ((long)(firstOp[0] << 1) != result[0])
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -365,18 +372,20 @@ private void ValidateResult(Int64[] firstOp, Int64[] result, [CallerMemberName]
                 {
                     if ((long)(firstOp[i] << 1) != result[i])
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Sse2)}.{nameof(Sse2.ShiftLeftLogical)}<Int64>(Vector128<Int64><9>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"  firstOp: ({string.Join(", ", firstOp)})");
                 TestLibrary.TestFramework.LogInformation($"   result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/ShiftLeftLogical.Int64.64.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/ShiftLeftLogical.Int64.64.cs
index ba3f39c27169..7a17fcf862bf 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/ShiftLeftLogical.Int64.64.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/ShiftLeftLogical.Int64.64.cs
@@ -319,7 +319,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -327,7 +327,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -355,9 +360,11 @@ private void ValidateResult(void* firstOp, void* result, [CallerMemberName] stri
 
         private void ValidateResult(Int64[] firstOp, Int64[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (0 != result[0])
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -365,18 +372,20 @@ private void ValidateResult(Int64[] firstOp, Int64[] result, [CallerMemberName]
                 {
                     if (0 != result[i])
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Sse2)}.{nameof(Sse2.ShiftLeftLogical)}<Int64>(Vector128<Int64><9>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"  firstOp: ({string.Join(", ", firstOp)})");
                 TestLibrary.TestFramework.LogInformation($"   result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/ShiftLeftLogical.UInt16.1.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/ShiftLeftLogical.UInt16.1.cs
index 04338cac5486..a9ae410e5f19 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/ShiftLeftLogical.UInt16.1.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/ShiftLeftLogical.UInt16.1.cs
@@ -319,7 +319,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -327,7 +327,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -355,9 +360,11 @@ private void ValidateResult(void* firstOp, void* result, [CallerMemberName] stri
 
         private void ValidateResult(UInt16[] firstOp, UInt16[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if ((ushort)(firstOp[0] << 1) != result[0])
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -365,18 +372,20 @@ private void ValidateResult(UInt16[] firstOp, UInt16[] result, [CallerMemberName
                 {
                     if ((ushort)(firstOp[i] << 1) != result[i])
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Sse2)}.{nameof(Sse2.ShiftLeftLogical)}<UInt16>(Vector128<UInt16><9>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"  firstOp: ({string.Join(", ", firstOp)})");
                 TestLibrary.TestFramework.LogInformation($"   result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/ShiftLeftLogical.UInt16.16.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/ShiftLeftLogical.UInt16.16.cs
index e10bdf5b347c..5801fd3d1c43 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/ShiftLeftLogical.UInt16.16.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/ShiftLeftLogical.UInt16.16.cs
@@ -319,7 +319,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -327,7 +327,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -355,9 +360,11 @@ private void ValidateResult(void* firstOp, void* result, [CallerMemberName] stri
 
         private void ValidateResult(UInt16[] firstOp, UInt16[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (0 != result[0])
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -365,18 +372,20 @@ private void ValidateResult(UInt16[] firstOp, UInt16[] result, [CallerMemberName
                 {
                     if (0 != result[i])
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Sse2)}.{nameof(Sse2.ShiftLeftLogical)}<UInt16>(Vector128<UInt16><9>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"  firstOp: ({string.Join(", ", firstOp)})");
                 TestLibrary.TestFramework.LogInformation($"   result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/ShiftLeftLogical.UInt32.1.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/ShiftLeftLogical.UInt32.1.cs
index a4a292767c8c..c083abf6c4aa 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/ShiftLeftLogical.UInt32.1.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/ShiftLeftLogical.UInt32.1.cs
@@ -319,7 +319,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -327,7 +327,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -355,9 +360,11 @@ private void ValidateResult(void* firstOp, void* result, [CallerMemberName] stri
 
         private void ValidateResult(UInt32[] firstOp, UInt32[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if ((uint)(firstOp[0] << 1) != result[0])
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -365,18 +372,20 @@ private void ValidateResult(UInt32[] firstOp, UInt32[] result, [CallerMemberName
                 {
                     if ((uint)(firstOp[i] << 1) != result[i])
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Sse2)}.{nameof(Sse2.ShiftLeftLogical)}<UInt32>(Vector128<UInt32><9>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"  firstOp: ({string.Join(", ", firstOp)})");
                 TestLibrary.TestFramework.LogInformation($"   result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/ShiftLeftLogical.UInt32.32.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/ShiftLeftLogical.UInt32.32.cs
index cb60ed5f8e2a..8a39b54dd203 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/ShiftLeftLogical.UInt32.32.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/ShiftLeftLogical.UInt32.32.cs
@@ -319,7 +319,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -327,7 +327,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -355,9 +360,11 @@ private void ValidateResult(void* firstOp, void* result, [CallerMemberName] stri
 
         private void ValidateResult(UInt32[] firstOp, UInt32[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (0 != result[0])
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -365,18 +372,20 @@ private void ValidateResult(UInt32[] firstOp, UInt32[] result, [CallerMemberName
                 {
                     if (0!= result[i])
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Sse2)}.{nameof(Sse2.ShiftLeftLogical)}<UInt32>(Vector128<UInt32><9>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"  firstOp: ({string.Join(", ", firstOp)})");
                 TestLibrary.TestFramework.LogInformation($"   result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/ShiftLeftLogical.UInt64.1.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/ShiftLeftLogical.UInt64.1.cs
index 902b3a8a5ee0..fa37db8e6364 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/ShiftLeftLogical.UInt64.1.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/ShiftLeftLogical.UInt64.1.cs
@@ -319,7 +319,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -327,7 +327,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -355,9 +360,11 @@ private void ValidateResult(void* firstOp, void* result, [CallerMemberName] stri
 
         private void ValidateResult(UInt64[] firstOp, UInt64[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if ((ulong)(firstOp[0] << 1) != result[0])
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -365,18 +372,20 @@ private void ValidateResult(UInt64[] firstOp, UInt64[] result, [CallerMemberName
                 {
                     if ((ulong)(firstOp[i] << 1) != result[i])
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Sse2)}.{nameof(Sse2.ShiftLeftLogical)}<UInt64>(Vector128<UInt64><9>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"  firstOp: ({string.Join(", ", firstOp)})");
                 TestLibrary.TestFramework.LogInformation($"   result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/ShiftLeftLogical.UInt64.64.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/ShiftLeftLogical.UInt64.64.cs
index 43ea12ecde69..5a656247732d 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/ShiftLeftLogical.UInt64.64.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/ShiftLeftLogical.UInt64.64.cs
@@ -319,7 +319,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -327,7 +327,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -355,9 +360,11 @@ private void ValidateResult(void* firstOp, void* result, [CallerMemberName] stri
 
         private void ValidateResult(UInt64[] firstOp, UInt64[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (0 != result[0])
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -365,18 +372,20 @@ private void ValidateResult(UInt64[] firstOp, UInt64[] result, [CallerMemberName
                 {
                     if (0 != result[i])
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Sse2)}.{nameof(Sse2.ShiftLeftLogical)}<UInt64>(Vector128<UInt64><9>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"  firstOp: ({string.Join(", ", firstOp)})");
                 TestLibrary.TestFramework.LogInformation($"   result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/ShiftLeftLogical128BitLane.Byte.1.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/ShiftLeftLogical128BitLane.Byte.1.cs
index dcd9a38dbb87..233142816ffd 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/ShiftLeftLogical128BitLane.Byte.1.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/ShiftLeftLogical128BitLane.Byte.1.cs
@@ -319,7 +319,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -327,7 +327,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -355,9 +360,11 @@ private void ValidateResult(void* firstOp, void* result, [CallerMemberName] stri
 
         private void ValidateResult(Byte[] firstOp, Byte[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (result[0] != 0)
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -365,18 +372,20 @@ private void ValidateResult(Byte[] firstOp, Byte[] result, [CallerMemberName] st
                 {
                     if (result[i] != 8)
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Sse2)}.{nameof(Sse2.ShiftLeftLogical128BitLane)}<Byte>(Vector128<Byte><9>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"  firstOp: ({string.Join(", ", firstOp)})");
                 TestLibrary.TestFramework.LogInformation($"   result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/ShiftLeftLogical128BitLane.Int16.1.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/ShiftLeftLogical128BitLane.Int16.1.cs
index aefbcfeb4da6..74e0c7a5c9b9 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/ShiftLeftLogical128BitLane.Int16.1.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/ShiftLeftLogical128BitLane.Int16.1.cs
@@ -319,7 +319,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -327,7 +327,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -355,9 +360,11 @@ private void ValidateResult(void* firstOp, void* result, [CallerMemberName] stri
 
         private void ValidateResult(Int16[] firstOp, Int16[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (result[0] != 2048)
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -365,18 +372,20 @@ private void ValidateResult(Int16[] firstOp, Int16[] result, [CallerMemberName]
                 {
                     if (result[i] != 2048)
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Sse2)}.{nameof(Sse2.ShiftLeftLogical128BitLane)}<Int16>(Vector128<Int16><9>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"  firstOp: ({string.Join(", ", firstOp)})");
                 TestLibrary.TestFramework.LogInformation($"   result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/ShiftLeftLogical128BitLane.Int32.1.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/ShiftLeftLogical128BitLane.Int32.1.cs
index 5c34dc0e0b3c..369b32ce2ba0 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/ShiftLeftLogical128BitLane.Int32.1.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/ShiftLeftLogical128BitLane.Int32.1.cs
@@ -319,7 +319,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -327,7 +327,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -355,9 +360,11 @@ private void ValidateResult(void* firstOp, void* result, [CallerMemberName] stri
 
         private void ValidateResult(Int32[] firstOp, Int32[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (result[0] != 2048)
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -365,18 +372,20 @@ private void ValidateResult(Int32[] firstOp, Int32[] result, [CallerMemberName]
                 {
                     if (result[i] != 2048)
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Sse2)}.{nameof(Sse2.ShiftLeftLogical128BitLane)}<Int32>(Vector128<Int32><9>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"  firstOp: ({string.Join(", ", firstOp)})");
                 TestLibrary.TestFramework.LogInformation($"   result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/ShiftLeftLogical128BitLane.Int64.1.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/ShiftLeftLogical128BitLane.Int64.1.cs
index 6eec46d66bcf..8333f3673a23 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/ShiftLeftLogical128BitLane.Int64.1.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/ShiftLeftLogical128BitLane.Int64.1.cs
@@ -319,7 +319,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -327,7 +327,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -355,9 +360,11 @@ private void ValidateResult(void* firstOp, void* result, [CallerMemberName] stri
 
         private void ValidateResult(Int64[] firstOp, Int64[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (result[0] != 2048)
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -365,18 +372,20 @@ private void ValidateResult(Int64[] firstOp, Int64[] result, [CallerMemberName]
                 {
                     if (result[i] != 2048)
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Sse2)}.{nameof(Sse2.ShiftLeftLogical128BitLane)}<Int64>(Vector128<Int64><9>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"  firstOp: ({string.Join(", ", firstOp)})");
                 TestLibrary.TestFramework.LogInformation($"   result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/ShiftLeftLogical128BitLane.SByte.1.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/ShiftLeftLogical128BitLane.SByte.1.cs
index 52f5939f086d..7d3960ecfec0 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/ShiftLeftLogical128BitLane.SByte.1.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/ShiftLeftLogical128BitLane.SByte.1.cs
@@ -319,7 +319,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -327,7 +327,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -355,9 +360,11 @@ private void ValidateResult(void* firstOp, void* result, [CallerMemberName] stri
 
         private void ValidateResult(SByte[] firstOp, SByte[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (result[0] != 0)
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -365,18 +372,20 @@ private void ValidateResult(SByte[] firstOp, SByte[] result, [CallerMemberName]
                 {
                     if (result[i] != 8)
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Sse2)}.{nameof(Sse2.ShiftLeftLogical128BitLane)}<SByte>(Vector128<SByte><9>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"  firstOp: ({string.Join(", ", firstOp)})");
                 TestLibrary.TestFramework.LogInformation($"   result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/ShiftLeftLogical128BitLane.UInt16.1.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/ShiftLeftLogical128BitLane.UInt16.1.cs
index 5c328404fe5e..27069da2c318 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/ShiftLeftLogical128BitLane.UInt16.1.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/ShiftLeftLogical128BitLane.UInt16.1.cs
@@ -319,7 +319,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -327,7 +327,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -355,9 +360,11 @@ private void ValidateResult(void* firstOp, void* result, [CallerMemberName] stri
 
         private void ValidateResult(UInt16[] firstOp, UInt16[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (result[0] != 2048)
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -365,18 +372,20 @@ private void ValidateResult(UInt16[] firstOp, UInt16[] result, [CallerMemberName
                 {
                     if (result[i] != 2048)
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Sse2)}.{nameof(Sse2.ShiftLeftLogical128BitLane)}<UInt16>(Vector128<UInt16><9>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"  firstOp: ({string.Join(", ", firstOp)})");
                 TestLibrary.TestFramework.LogInformation($"   result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/ShiftLeftLogical128BitLane.UInt32.1.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/ShiftLeftLogical128BitLane.UInt32.1.cs
index 6c188673ebaa..d360b159d5bd 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/ShiftLeftLogical128BitLane.UInt32.1.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/ShiftLeftLogical128BitLane.UInt32.1.cs
@@ -319,7 +319,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -327,7 +327,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -355,9 +360,11 @@ private void ValidateResult(void* firstOp, void* result, [CallerMemberName] stri
 
         private void ValidateResult(UInt32[] firstOp, UInt32[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (result[0] != 2048)
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -365,18 +372,20 @@ private void ValidateResult(UInt32[] firstOp, UInt32[] result, [CallerMemberName
                 {
                     if (result[i] != 2048)
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Sse2)}.{nameof(Sse2.ShiftLeftLogical128BitLane)}<UInt32>(Vector128<UInt32><9>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"  firstOp: ({string.Join(", ", firstOp)})");
                 TestLibrary.TestFramework.LogInformation($"   result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/ShiftLeftLogical128BitLane.UInt64.1.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/ShiftLeftLogical128BitLane.UInt64.1.cs
index 514c7c7f6737..ae3e8a5038bc 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/ShiftLeftLogical128BitLane.UInt64.1.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/ShiftLeftLogical128BitLane.UInt64.1.cs
@@ -319,7 +319,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -327,7 +327,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -355,9 +360,11 @@ private void ValidateResult(void* firstOp, void* result, [CallerMemberName] stri
 
         private void ValidateResult(UInt64[] firstOp, UInt64[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (result[0] != 2048)
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -365,18 +372,20 @@ private void ValidateResult(UInt64[] firstOp, UInt64[] result, [CallerMemberName
                 {
                     if (result[i] != 2048)
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Sse2)}.{nameof(Sse2.ShiftLeftLogical128BitLane)}<UInt64>(Vector128<UInt64><9>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"  firstOp: ({string.Join(", ", firstOp)})");
                 TestLibrary.TestFramework.LogInformation($"   result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/ShiftRightArithmetic.Int16.1.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/ShiftRightArithmetic.Int16.1.cs
index 3e9110001464..92f61982dff1 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/ShiftRightArithmetic.Int16.1.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/ShiftRightArithmetic.Int16.1.cs
@@ -319,7 +319,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -327,7 +327,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -355,9 +360,11 @@ private void ValidateResult(void* firstOp, void* result, [CallerMemberName] stri
 
         private void ValidateResult(Int16[] firstOp, Int16[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if ((short)(firstOp[0] >> 1) != result[0])
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -365,18 +372,20 @@ private void ValidateResult(Int16[] firstOp, Int16[] result, [CallerMemberName]
                 {
                     if ((short)(firstOp[i] >> 1) != result[i])
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Sse2)}.{nameof(Sse2.ShiftRightArithmetic)}<Int16>(Vector128<Int16><9>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"  firstOp: ({string.Join(", ", firstOp)})");
                 TestLibrary.TestFramework.LogInformation($"   result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/ShiftRightArithmetic.Int16.16.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/ShiftRightArithmetic.Int16.16.cs
index 90676a2596bc..0945fc0c3308 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/ShiftRightArithmetic.Int16.16.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/ShiftRightArithmetic.Int16.16.cs
@@ -319,7 +319,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -327,7 +327,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -355,9 +360,11 @@ private void ValidateResult(void* firstOp, void* result, [CallerMemberName] stri
 
         private void ValidateResult(Int16[] firstOp, Int16[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if ((short)(firstOp[0] >> 15) != result[0])
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -365,18 +372,20 @@ private void ValidateResult(Int16[] firstOp, Int16[] result, [CallerMemberName]
                 {
                     if ((short)(firstOp[i] >> 15) != result[i])
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Sse2)}.{nameof(Sse2.ShiftRightArithmetic)}<Int16>(Vector128<Int16><9>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"  firstOp: ({string.Join(", ", firstOp)})");
                 TestLibrary.TestFramework.LogInformation($"   result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/ShiftRightArithmetic.Int32.1.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/ShiftRightArithmetic.Int32.1.cs
index eb4bc0e6e5d3..c26c37c0cbdd 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/ShiftRightArithmetic.Int32.1.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/ShiftRightArithmetic.Int32.1.cs
@@ -319,7 +319,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -327,7 +327,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -355,9 +360,11 @@ private void ValidateResult(void* firstOp, void* result, [CallerMemberName] stri
 
         private void ValidateResult(Int32[] firstOp, Int32[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if ((int)(firstOp[0] >> 1) != result[0])
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -365,18 +372,20 @@ private void ValidateResult(Int32[] firstOp, Int32[] result, [CallerMemberName]
                 {
                     if ((int)(firstOp[i] >> 1) != result[i])
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Sse2)}.{nameof(Sse2.ShiftRightArithmetic)}<Int32>(Vector128<Int32><9>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"  firstOp: ({string.Join(", ", firstOp)})");
                 TestLibrary.TestFramework.LogInformation($"   result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/ShiftRightArithmetic.Int32.32.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/ShiftRightArithmetic.Int32.32.cs
index 8d7c25184f5c..151d4a7c1eac 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/ShiftRightArithmetic.Int32.32.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/ShiftRightArithmetic.Int32.32.cs
@@ -319,7 +319,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -327,7 +327,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -355,9 +360,11 @@ private void ValidateResult(void* firstOp, void* result, [CallerMemberName] stri
 
         private void ValidateResult(Int32[] firstOp, Int32[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if ((int)(firstOp[0] >> 31) != result[0])
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -365,18 +372,20 @@ private void ValidateResult(Int32[] firstOp, Int32[] result, [CallerMemberName]
                 {
                     if ((int)(firstOp[i] >> 31) != result[i])
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Sse2)}.{nameof(Sse2.ShiftRightArithmetic)}<Int32>(Vector128<Int32><9>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"  firstOp: ({string.Join(", ", firstOp)})");
                 TestLibrary.TestFramework.LogInformation($"   result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/ShiftRightLogical.Int16.1.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/ShiftRightLogical.Int16.1.cs
index 4b0536af3ffe..fbac4c2e46ba 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/ShiftRightLogical.Int16.1.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/ShiftRightLogical.Int16.1.cs
@@ -319,7 +319,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -327,7 +327,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -355,9 +360,11 @@ private void ValidateResult(void* firstOp, void* result, [CallerMemberName] stri
 
         private void ValidateResult(Int16[] firstOp, Int16[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if ((short)(firstOp[0] >> 1) != result[0])
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -365,18 +372,20 @@ private void ValidateResult(Int16[] firstOp, Int16[] result, [CallerMemberName]
                 {
                     if ((short)(firstOp[i] >> 1) != result[i])
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Sse2)}.{nameof(Sse2.ShiftRightLogical)}<Int16>(Vector128<Int16><9>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"  firstOp: ({string.Join(", ", firstOp)})");
                 TestLibrary.TestFramework.LogInformation($"   result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/ShiftRightLogical.Int16.16.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/ShiftRightLogical.Int16.16.cs
index 3d46689e9283..2f520feb1015 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/ShiftRightLogical.Int16.16.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/ShiftRightLogical.Int16.16.cs
@@ -319,7 +319,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -327,7 +327,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -355,9 +360,11 @@ private void ValidateResult(void* firstOp, void* result, [CallerMemberName] stri
 
         private void ValidateResult(Int16[] firstOp, Int16[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (0 != result[0])
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -365,18 +372,20 @@ private void ValidateResult(Int16[] firstOp, Int16[] result, [CallerMemberName]
                 {
                     if (0 != result[i])
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Sse2)}.{nameof(Sse2.ShiftRightLogical)}<Int16>(Vector128<Int16><9>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"  firstOp: ({string.Join(", ", firstOp)})");
                 TestLibrary.TestFramework.LogInformation($"   result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/ShiftRightLogical.Int32.1.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/ShiftRightLogical.Int32.1.cs
index 688900b4b902..4940a852b866 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/ShiftRightLogical.Int32.1.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/ShiftRightLogical.Int32.1.cs
@@ -319,7 +319,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -327,7 +327,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -355,9 +360,11 @@ private void ValidateResult(void* firstOp, void* result, [CallerMemberName] stri
 
         private void ValidateResult(Int32[] firstOp, Int32[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if ((int)(firstOp[0] >> 1) != result[0])
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -365,18 +372,20 @@ private void ValidateResult(Int32[] firstOp, Int32[] result, [CallerMemberName]
                 {
                     if ((int)(firstOp[i] >> 1) != result[i])
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Sse2)}.{nameof(Sse2.ShiftRightLogical)}<Int32>(Vector128<Int32><9>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"  firstOp: ({string.Join(", ", firstOp)})");
                 TestLibrary.TestFramework.LogInformation($"   result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/ShiftRightLogical.Int32.32.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/ShiftRightLogical.Int32.32.cs
index 6e274602dea0..6ff880b14eda 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/ShiftRightLogical.Int32.32.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/ShiftRightLogical.Int32.32.cs
@@ -319,7 +319,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -327,7 +327,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -355,9 +360,11 @@ private void ValidateResult(void* firstOp, void* result, [CallerMemberName] stri
 
         private void ValidateResult(Int32[] firstOp, Int32[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (0 != result[0])
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -365,18 +372,20 @@ private void ValidateResult(Int32[] firstOp, Int32[] result, [CallerMemberName]
                 {
                     if (0 != result[i])
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Sse2)}.{nameof(Sse2.ShiftRightLogical)}<Int32>(Vector128<Int32><9>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"  firstOp: ({string.Join(", ", firstOp)})");
                 TestLibrary.TestFramework.LogInformation($"   result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/ShiftRightLogical.Int64.1.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/ShiftRightLogical.Int64.1.cs
index 4a1bfefe488b..4541cb6911d8 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/ShiftRightLogical.Int64.1.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/ShiftRightLogical.Int64.1.cs
@@ -319,7 +319,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -327,7 +327,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -355,9 +360,11 @@ private void ValidateResult(void* firstOp, void* result, [CallerMemberName] stri
 
         private void ValidateResult(Int64[] firstOp, Int64[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if ((long)(firstOp[0] >> 1) != result[0])
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -365,18 +372,20 @@ private void ValidateResult(Int64[] firstOp, Int64[] result, [CallerMemberName]
                 {
                     if ((long)(firstOp[i] >> 1) != result[i])
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Sse2)}.{nameof(Sse2.ShiftRightLogical)}<Int64>(Vector128<Int64><9>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"  firstOp: ({string.Join(", ", firstOp)})");
                 TestLibrary.TestFramework.LogInformation($"   result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/ShiftRightLogical.Int64.64.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/ShiftRightLogical.Int64.64.cs
index ba7aaa793161..c76f04e000e7 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/ShiftRightLogical.Int64.64.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/ShiftRightLogical.Int64.64.cs
@@ -319,7 +319,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -327,7 +327,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -355,9 +360,11 @@ private void ValidateResult(void* firstOp, void* result, [CallerMemberName] stri
 
         private void ValidateResult(Int64[] firstOp, Int64[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (0 != result[0])
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -365,18 +372,20 @@ private void ValidateResult(Int64[] firstOp, Int64[] result, [CallerMemberName]
                 {
                     if (0 != result[i])
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Sse2)}.{nameof(Sse2.ShiftRightLogical)}<Int64>(Vector128<Int64><9>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"  firstOp: ({string.Join(", ", firstOp)})");
                 TestLibrary.TestFramework.LogInformation($"   result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/ShiftRightLogical.UInt16.1.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/ShiftRightLogical.UInt16.1.cs
index 6a434559dc02..b4cd2548aed3 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/ShiftRightLogical.UInt16.1.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/ShiftRightLogical.UInt16.1.cs
@@ -319,7 +319,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -327,7 +327,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -355,9 +360,11 @@ private void ValidateResult(void* firstOp, void* result, [CallerMemberName] stri
 
         private void ValidateResult(UInt16[] firstOp, UInt16[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if ((ushort)(firstOp[0] >> 1) != result[0])
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -365,18 +372,20 @@ private void ValidateResult(UInt16[] firstOp, UInt16[] result, [CallerMemberName
                 {
                     if ((ushort)(firstOp[i] >> 1) != result[i])
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Sse2)}.{nameof(Sse2.ShiftRightLogical)}<UInt16>(Vector128<UInt16><9>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"  firstOp: ({string.Join(", ", firstOp)})");
                 TestLibrary.TestFramework.LogInformation($"   result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/ShiftRightLogical.UInt16.16.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/ShiftRightLogical.UInt16.16.cs
index 59b3c4abccc0..c8e56a8fb8d2 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/ShiftRightLogical.UInt16.16.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/ShiftRightLogical.UInt16.16.cs
@@ -319,7 +319,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -327,7 +327,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -355,9 +360,11 @@ private void ValidateResult(void* firstOp, void* result, [CallerMemberName] stri
 
         private void ValidateResult(UInt16[] firstOp, UInt16[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (0 != result[0])
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -365,18 +372,20 @@ private void ValidateResult(UInt16[] firstOp, UInt16[] result, [CallerMemberName
                 {
                     if (0 != result[i])
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Sse2)}.{nameof(Sse2.ShiftRightLogical)}<UInt16>(Vector128<UInt16><9>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"  firstOp: ({string.Join(", ", firstOp)})");
                 TestLibrary.TestFramework.LogInformation($"   result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/ShiftRightLogical.UInt32.1.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/ShiftRightLogical.UInt32.1.cs
index a442e1051d1d..43ee165e16d6 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/ShiftRightLogical.UInt32.1.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/ShiftRightLogical.UInt32.1.cs
@@ -319,7 +319,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -327,7 +327,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -355,9 +360,11 @@ private void ValidateResult(void* firstOp, void* result, [CallerMemberName] stri
 
         private void ValidateResult(UInt32[] firstOp, UInt32[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if ((uint)(firstOp[0] >> 1) != result[0])
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -365,18 +372,20 @@ private void ValidateResult(UInt32[] firstOp, UInt32[] result, [CallerMemberName
                 {
                     if ((uint)(firstOp[i] >> 1) != result[i])
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Sse2)}.{nameof(Sse2.ShiftRightLogical)}<UInt32>(Vector128<UInt32><9>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"  firstOp: ({string.Join(", ", firstOp)})");
                 TestLibrary.TestFramework.LogInformation($"   result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/ShiftRightLogical.UInt32.32.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/ShiftRightLogical.UInt32.32.cs
index d3040c696679..57f79c4fdffb 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/ShiftRightLogical.UInt32.32.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/ShiftRightLogical.UInt32.32.cs
@@ -319,7 +319,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -327,7 +327,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -355,9 +360,11 @@ private void ValidateResult(void* firstOp, void* result, [CallerMemberName] stri
 
         private void ValidateResult(UInt32[] firstOp, UInt32[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (0 != result[0])
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -365,18 +372,20 @@ private void ValidateResult(UInt32[] firstOp, UInt32[] result, [CallerMemberName
                 {
                     if (0!= result[i])
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Sse2)}.{nameof(Sse2.ShiftRightLogical)}<UInt32>(Vector128<UInt32><9>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"  firstOp: ({string.Join(", ", firstOp)})");
                 TestLibrary.TestFramework.LogInformation($"   result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/ShiftRightLogical.UInt64.1.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/ShiftRightLogical.UInt64.1.cs
index 0897095e8fa6..8434630150d3 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/ShiftRightLogical.UInt64.1.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/ShiftRightLogical.UInt64.1.cs
@@ -319,7 +319,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -327,7 +327,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -355,9 +360,11 @@ private void ValidateResult(void* firstOp, void* result, [CallerMemberName] stri
 
         private void ValidateResult(UInt64[] firstOp, UInt64[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if ((ulong)(firstOp[0] >> 1) != result[0])
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -365,18 +372,20 @@ private void ValidateResult(UInt64[] firstOp, UInt64[] result, [CallerMemberName
                 {
                     if ((ulong)(firstOp[i] >> 1) != result[i])
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Sse2)}.{nameof(Sse2.ShiftRightLogical)}<UInt64>(Vector128<UInt64><9>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"  firstOp: ({string.Join(", ", firstOp)})");
                 TestLibrary.TestFramework.LogInformation($"   result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/ShiftRightLogical.UInt64.64.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/ShiftRightLogical.UInt64.64.cs
index 466e3c4ad1ab..95d5c64d9cd3 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/ShiftRightLogical.UInt64.64.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/ShiftRightLogical.UInt64.64.cs
@@ -319,7 +319,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -327,7 +327,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -355,9 +360,11 @@ private void ValidateResult(void* firstOp, void* result, [CallerMemberName] stri
 
         private void ValidateResult(UInt64[] firstOp, UInt64[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (0 != result[0])
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -365,18 +372,20 @@ private void ValidateResult(UInt64[] firstOp, UInt64[] result, [CallerMemberName
                 {
                     if (0 != result[i])
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Sse2)}.{nameof(Sse2.ShiftRightLogical)}<UInt64>(Vector128<UInt64><9>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"  firstOp: ({string.Join(", ", firstOp)})");
                 TestLibrary.TestFramework.LogInformation($"   result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/ShiftRightLogical128BitLane.Byte.1.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/ShiftRightLogical128BitLane.Byte.1.cs
index 6f49c9600a06..28f5f91dc6f5 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/ShiftRightLogical128BitLane.Byte.1.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/ShiftRightLogical128BitLane.Byte.1.cs
@@ -319,7 +319,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -327,7 +327,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -355,9 +360,11 @@ private void ValidateResult(void* firstOp, void* result, [CallerMemberName] stri
 
         private void ValidateResult(Byte[] firstOp, Byte[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (result[0] != 8)
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -365,18 +372,20 @@ private void ValidateResult(Byte[] firstOp, Byte[] result, [CallerMemberName] st
                 {
                     if ((i == 15 ? result[i] != 0 : result[i] != 8))
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Sse2)}.{nameof(Sse2.ShiftRightLogical128BitLane)}<Byte>(Vector128<Byte><9>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"  firstOp: ({string.Join(", ", firstOp)})");
                 TestLibrary.TestFramework.LogInformation($"   result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/ShiftRightLogical128BitLane.Int16.1.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/ShiftRightLogical128BitLane.Int16.1.cs
index 0999efde8868..1618c8434676 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/ShiftRightLogical128BitLane.Int16.1.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/ShiftRightLogical128BitLane.Int16.1.cs
@@ -319,7 +319,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -327,7 +327,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -355,9 +360,11 @@ private void ValidateResult(void* firstOp, void* result, [CallerMemberName] stri
 
         private void ValidateResult(Int16[] firstOp, Int16[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (result[0] != 2048)
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -365,18 +372,20 @@ private void ValidateResult(Int16[] firstOp, Int16[] result, [CallerMemberName]
                 {
                     if ((i == 7 ? result[i] != 0 : result[i] != 2048))
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Sse2)}.{nameof(Sse2.ShiftRightLogical128BitLane)}<Int16>(Vector128<Int16><9>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"  firstOp: ({string.Join(", ", firstOp)})");
                 TestLibrary.TestFramework.LogInformation($"   result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/ShiftRightLogical128BitLane.Int32.1.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/ShiftRightLogical128BitLane.Int32.1.cs
index f65579d4b277..a94fd63a4e5e 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/ShiftRightLogical128BitLane.Int32.1.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/ShiftRightLogical128BitLane.Int32.1.cs
@@ -319,7 +319,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -327,7 +327,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -355,9 +360,11 @@ private void ValidateResult(void* firstOp, void* result, [CallerMemberName] stri
 
         private void ValidateResult(Int32[] firstOp, Int32[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (result[0] != 134217728)
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -365,18 +372,20 @@ private void ValidateResult(Int32[] firstOp, Int32[] result, [CallerMemberName]
                 {
                     if ((i == 3 ? result[i] != 0 : result[i] != 134217728))
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Sse2)}.{nameof(Sse2.ShiftRightLogical128BitLane)}<Int32>(Vector128<Int32><9>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"  firstOp: ({string.Join(", ", firstOp)})");
                 TestLibrary.TestFramework.LogInformation($"   result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/ShiftRightLogical128BitLane.Int64.1.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/ShiftRightLogical128BitLane.Int64.1.cs
index 5300e80aff9c..ac8dc496ff83 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/ShiftRightLogical128BitLane.Int64.1.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/ShiftRightLogical128BitLane.Int64.1.cs
@@ -319,7 +319,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -327,7 +327,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -355,9 +360,11 @@ private void ValidateResult(void* firstOp, void* result, [CallerMemberName] stri
 
         private void ValidateResult(Int64[] firstOp, Int64[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (result[0] != 576460752303423488L)
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -365,18 +372,20 @@ private void ValidateResult(Int64[] firstOp, Int64[] result, [CallerMemberName]
                 {
                     if ((result[i] != 0))
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Sse2)}.{nameof(Sse2.ShiftRightLogical128BitLane)}<Int64>(Vector128<Int64><9>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"  firstOp: ({string.Join(", ", firstOp)})");
                 TestLibrary.TestFramework.LogInformation($"   result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/ShiftRightLogical128BitLane.SByte.1.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/ShiftRightLogical128BitLane.SByte.1.cs
index 033323bbed18..e116ce417d33 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/ShiftRightLogical128BitLane.SByte.1.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/ShiftRightLogical128BitLane.SByte.1.cs
@@ -319,7 +319,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -327,7 +327,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -355,9 +360,11 @@ private void ValidateResult(void* firstOp, void* result, [CallerMemberName] stri
 
         private void ValidateResult(SByte[] firstOp, SByte[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (result[0] != 8)
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -365,18 +372,20 @@ private void ValidateResult(SByte[] firstOp, SByte[] result, [CallerMemberName]
                 {
                     if ((i == 15 ? result[i] != 0 : result[i] != 8))
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Sse2)}.{nameof(Sse2.ShiftRightLogical128BitLane)}<SByte>(Vector128<SByte><9>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"  firstOp: ({string.Join(", ", firstOp)})");
                 TestLibrary.TestFramework.LogInformation($"   result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/ShiftRightLogical128BitLane.UInt16.1.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/ShiftRightLogical128BitLane.UInt16.1.cs
index 680413d1f370..80ec3c8a3f7d 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/ShiftRightLogical128BitLane.UInt16.1.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/ShiftRightLogical128BitLane.UInt16.1.cs
@@ -319,7 +319,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -327,7 +327,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -355,9 +360,11 @@ private void ValidateResult(void* firstOp, void* result, [CallerMemberName] stri
 
         private void ValidateResult(UInt16[] firstOp, UInt16[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (result[0] != 2048)
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -365,18 +372,20 @@ private void ValidateResult(UInt16[] firstOp, UInt16[] result, [CallerMemberName
                 {
                     if ((i == 7 ? result[i] != 0 : result[i] != 2048))
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Sse2)}.{nameof(Sse2.ShiftRightLogical128BitLane)}<UInt16>(Vector128<UInt16><9>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"  firstOp: ({string.Join(", ", firstOp)})");
                 TestLibrary.TestFramework.LogInformation($"   result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/ShiftRightLogical128BitLane.UInt32.1.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/ShiftRightLogical128BitLane.UInt32.1.cs
index 77522787bf54..25fb9b80b109 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/ShiftRightLogical128BitLane.UInt32.1.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/ShiftRightLogical128BitLane.UInt32.1.cs
@@ -319,7 +319,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -327,7 +327,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -355,9 +360,11 @@ private void ValidateResult(void* firstOp, void* result, [CallerMemberName] stri
 
         private void ValidateResult(UInt32[] firstOp, UInt32[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (result[0] != 134217728)
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -365,18 +372,20 @@ private void ValidateResult(UInt32[] firstOp, UInt32[] result, [CallerMemberName
                 {
                     if ((i == 3 ? result[i] != 0 : result[i] != 134217728))
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Sse2)}.{nameof(Sse2.ShiftRightLogical128BitLane)}<UInt32>(Vector128<UInt32><9>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"  firstOp: ({string.Join(", ", firstOp)})");
                 TestLibrary.TestFramework.LogInformation($"   result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/ShiftRightLogical128BitLane.UInt64.1.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/ShiftRightLogical128BitLane.UInt64.1.cs
index d82937e10fb7..1710c620330e 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/ShiftRightLogical128BitLane.UInt64.1.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/ShiftRightLogical128BitLane.UInt64.1.cs
@@ -319,7 +319,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -327,7 +327,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -355,9 +360,11 @@ private void ValidateResult(void* firstOp, void* result, [CallerMemberName] stri
 
         private void ValidateResult(UInt64[] firstOp, UInt64[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (result[0] != 576460752303423488UL)
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -365,18 +372,20 @@ private void ValidateResult(UInt64[] firstOp, UInt64[] result, [CallerMemberName
                 {
                     if ((result[i] != 0))
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Sse2)}.{nameof(Sse2.ShiftRightLogical128BitLane)}<UInt64>(Vector128<UInt64><9>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"  firstOp: ({string.Join(", ", firstOp)})");
                 TestLibrary.TestFramework.LogInformation($"   result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/Subtract.Byte.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/Subtract.Byte.cs
index 559c2d96ec32..df2098232304 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/Subtract.Byte.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/Subtract.Byte.cs
@@ -334,7 +334,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -342,7 +342,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -374,9 +379,11 @@ private void ValidateResult(void* left, void* right, void* result, [CallerMember
 
         private void ValidateResult(Byte[] left, Byte[] right, Byte[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if ((byte)(left[0] - right[0]) != result[0])
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -384,19 +391,21 @@ private void ValidateResult(Byte[] left, Byte[] right, Byte[] result, [CallerMem
                 {
                     if ((byte)(left[i] - right[i]) != result[i])
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Sse2)}.{nameof(Sse2.Subtract)}<Byte>(Vector128<Byte>, Vector128<Byte>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/Subtract.Double.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/Subtract.Double.cs
index 589e57047852..1bd3edfa4bee 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/Subtract.Double.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/Subtract.Double.cs
@@ -334,7 +334,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -342,7 +342,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -374,9 +379,11 @@ private void ValidateResult(void* left, void* right, void* result, [CallerMember
 
         private void ValidateResult(Double[] left, Double[] right, Double[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (BitConverter.DoubleToInt64Bits(left[0] - right[0]) != BitConverter.DoubleToInt64Bits(result[0]))
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -384,19 +391,21 @@ private void ValidateResult(Double[] left, Double[] right, Double[] result, [Cal
                 {
                     if (BitConverter.DoubleToInt64Bits(left[i] - right[i]) != BitConverter.DoubleToInt64Bits(result[i]))
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Sse2)}.{nameof(Sse2.Subtract)}<Double>(Vector128<Double>, Vector128<Double>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/Subtract.Int16.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/Subtract.Int16.cs
index 0680a1d76afc..42c3fdbb5675 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/Subtract.Int16.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/Subtract.Int16.cs
@@ -334,7 +334,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -342,7 +342,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -374,9 +379,11 @@ private void ValidateResult(void* left, void* right, void* result, [CallerMember
 
         private void ValidateResult(Int16[] left, Int16[] right, Int16[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if ((short)(left[0] - right[0]) != result[0])
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -384,19 +391,21 @@ private void ValidateResult(Int16[] left, Int16[] right, Int16[] result, [Caller
                 {
                     if ((short)(left[i] - right[i]) != result[i])
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Sse2)}.{nameof(Sse2.Subtract)}<Int16>(Vector128<Int16>, Vector128<Int16>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/Subtract.Int32.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/Subtract.Int32.cs
index db266d83e326..b4a5d46d6c00 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/Subtract.Int32.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/Subtract.Int32.cs
@@ -334,7 +334,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -342,7 +342,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -374,9 +379,11 @@ private void ValidateResult(void* left, void* right, void* result, [CallerMember
 
         private void ValidateResult(Int32[] left, Int32[] right, Int32[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if ((int)(left[0] - right[0]) != result[0])
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -384,19 +391,21 @@ private void ValidateResult(Int32[] left, Int32[] right, Int32[] result, [Caller
                 {
                     if ((int)(left[i] - right[i]) != result[i])
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Sse2)}.{nameof(Sse2.Subtract)}<Int32>(Vector128<Int32>, Vector128<Int32>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/Subtract.Int64.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/Subtract.Int64.cs
index 02673138192d..37e5b9678911 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/Subtract.Int64.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/Subtract.Int64.cs
@@ -334,7 +334,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -342,7 +342,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -374,9 +379,11 @@ private void ValidateResult(void* left, void* right, void* result, [CallerMember
 
         private void ValidateResult(Int64[] left, Int64[] right, Int64[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if ((long)(left[0] - right[0]) != result[0])
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -384,19 +391,21 @@ private void ValidateResult(Int64[] left, Int64[] right, Int64[] result, [Caller
                 {
                     if ((long)(left[i] - right[i]) != result[i])
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Sse2)}.{nameof(Sse2.Subtract)}<Int64>(Vector128<Int64>, Vector128<Int64>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/Subtract.SByte.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/Subtract.SByte.cs
index a966a586a188..0152ada3f4c9 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/Subtract.SByte.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/Subtract.SByte.cs
@@ -334,7 +334,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -342,7 +342,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -374,9 +379,11 @@ private void ValidateResult(void* left, void* right, void* result, [CallerMember
 
         private void ValidateResult(SByte[] left, SByte[] right, SByte[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if ((sbyte)(left[0] - right[0]) != result[0])
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -384,19 +391,21 @@ private void ValidateResult(SByte[] left, SByte[] right, SByte[] result, [Caller
                 {
                     if ((sbyte)(left[i] - right[i]) != result[i])
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Sse2)}.{nameof(Sse2.Subtract)}<SByte>(Vector128<SByte>, Vector128<SByte>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/Subtract.UInt16.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/Subtract.UInt16.cs
index bc33d611357d..0ec4658eec5e 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/Subtract.UInt16.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/Subtract.UInt16.cs
@@ -334,7 +334,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -342,7 +342,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -374,9 +379,11 @@ private void ValidateResult(void* left, void* right, void* result, [CallerMember
 
         private void ValidateResult(UInt16[] left, UInt16[] right, UInt16[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if ((ushort)(left[0] - right[0]) != result[0])
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -384,19 +391,21 @@ private void ValidateResult(UInt16[] left, UInt16[] right, UInt16[] result, [Cal
                 {
                     if ((ushort)(left[i] - right[i]) != result[i])
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Sse2)}.{nameof(Sse2.Subtract)}<UInt16>(Vector128<UInt16>, Vector128<UInt16>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/Subtract.UInt32.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/Subtract.UInt32.cs
index 2f1e8d3d6947..ae3d7bb43739 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/Subtract.UInt32.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/Subtract.UInt32.cs
@@ -334,7 +334,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -342,7 +342,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -374,9 +379,11 @@ private void ValidateResult(void* left, void* right, void* result, [CallerMember
 
         private void ValidateResult(UInt32[] left, UInt32[] right, UInt32[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if ((uint)(left[0] - right[0]) != result[0])
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -384,19 +391,21 @@ private void ValidateResult(UInt32[] left, UInt32[] right, UInt32[] result, [Cal
                 {
                     if ((uint)(left[i] - right[i]) != result[i])
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Sse2)}.{nameof(Sse2.Subtract)}<UInt32>(Vector128<UInt32>, Vector128<UInt32>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/Subtract.UInt64.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/Subtract.UInt64.cs
index 775fee3b4e85..0c3c6a0a969d 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/Subtract.UInt64.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/Subtract.UInt64.cs
@@ -334,7 +334,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -342,7 +342,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -374,9 +379,11 @@ private void ValidateResult(void* left, void* right, void* result, [CallerMember
 
         private void ValidateResult(UInt64[] left, UInt64[] right, UInt64[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if ((ulong)(left[0] - right[0]) != result[0])
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -384,19 +391,21 @@ private void ValidateResult(UInt64[] left, UInt64[] right, UInt64[] result, [Cal
                 {
                     if ((ulong)(left[i] - right[i]) != result[i])
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Sse2)}.{nameof(Sse2.Subtract)}<UInt64>(Vector128<UInt64>, Vector128<UInt64>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/SubtractSaturate.Byte.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/SubtractSaturate.Byte.cs
index 90b403d157b9..07b749f89c04 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/SubtractSaturate.Byte.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/SubtractSaturate.Byte.cs
@@ -334,7 +334,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -342,7 +342,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -374,9 +379,11 @@ private void ValidateResult(void* left, void* right, void* result, [CallerMember
 
         private void ValidateResult(Byte[] left, Byte[] right, Byte[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (Sse2Verify.SubtractSaturate(left[0], right[0], result[0]))
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -384,19 +391,21 @@ private void ValidateResult(Byte[] left, Byte[] right, Byte[] result, [CallerMem
                 {
                     if (Sse2Verify.SubtractSaturate(left[i], right[i], result[i]))
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Sse2)}.{nameof(Sse2.SubtractSaturate)}<Byte>(Vector128<Byte>, Vector128<Byte>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/SubtractSaturate.Int16.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/SubtractSaturate.Int16.cs
index 480dc062f4b8..62e0c910a24f 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/SubtractSaturate.Int16.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/SubtractSaturate.Int16.cs
@@ -334,7 +334,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -342,7 +342,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -374,9 +379,11 @@ private void ValidateResult(void* left, void* right, void* result, [CallerMember
 
         private void ValidateResult(Int16[] left, Int16[] right, Int16[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (Sse2Verify.SubtractSaturate(left[0], right[0], result[0]))
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -384,19 +391,21 @@ private void ValidateResult(Int16[] left, Int16[] right, Int16[] result, [Caller
                 {
                     if (Sse2Verify.SubtractSaturate(left[i], right[i], result[i]))
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Sse2)}.{nameof(Sse2.SubtractSaturate)}<Int16>(Vector128<Int16>, Vector128<Int16>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/SubtractSaturate.SByte.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/SubtractSaturate.SByte.cs
index e7838d0ac31a..fa27f8e10b9c 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/SubtractSaturate.SByte.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/SubtractSaturate.SByte.cs
@@ -334,7 +334,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -342,7 +342,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -374,9 +379,11 @@ private void ValidateResult(void* left, void* right, void* result, [CallerMember
 
         private void ValidateResult(SByte[] left, SByte[] right, SByte[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (Sse2Verify.SubtractSaturate(left[0], right[0], result[0]))
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -384,19 +391,21 @@ private void ValidateResult(SByte[] left, SByte[] right, SByte[] result, [Caller
                 {
                     if (Sse2Verify.SubtractSaturate(left[i], right[i], result[i]))
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Sse2)}.{nameof(Sse2.SubtractSaturate)}<SByte>(Vector128<SByte>, Vector128<SByte>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/SubtractSaturate.UInt16.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/SubtractSaturate.UInt16.cs
index 7f40054712a0..da581efc1546 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/SubtractSaturate.UInt16.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/SubtractSaturate.UInt16.cs
@@ -334,7 +334,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -342,7 +342,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -374,9 +379,11 @@ private void ValidateResult(void* left, void* right, void* result, [CallerMember
 
         private void ValidateResult(UInt16[] left, UInt16[] right, UInt16[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (Sse2Verify.SubtractSaturate(left[0], right[0], result[0]))
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -384,19 +391,21 @@ private void ValidateResult(UInt16[] left, UInt16[] right, UInt16[] result, [Cal
                 {
                     if (Sse2Verify.SubtractSaturate(left[i], right[i], result[i]))
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Sse2)}.{nameof(Sse2.SubtractSaturate)}<UInt16>(Vector128<UInt16>, Vector128<UInt16>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/SubtractScalar.Double.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/SubtractScalar.Double.cs
index 363d46d8f5fe..e28195d2784b 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/SubtractScalar.Double.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/SubtractScalar.Double.cs
@@ -334,7 +334,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -342,7 +342,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -374,9 +379,11 @@ private void ValidateResult(void* left, void* right, void* result, [CallerMember
 
         private void ValidateResult(Double[] left, Double[] right, Double[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (BitConverter.DoubleToInt64Bits(left[0] - right[0]) != BitConverter.DoubleToInt64Bits(result[0]))
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -384,19 +391,21 @@ private void ValidateResult(Double[] left, Double[] right, Double[] result, [Cal
                 {
                     if (BitConverter.DoubleToInt64Bits(left[i]) != BitConverter.DoubleToInt64Bits(result[i]))
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Sse2)}.{nameof(Sse2.SubtractScalar)}<Double>(Vector128<Double>, Vector128<Double>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/SumAbsoluteDifferences.UInt16.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/SumAbsoluteDifferences.UInt16.cs
index be18337a14cc..be81267c1698 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/SumAbsoluteDifferences.UInt16.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/SumAbsoluteDifferences.UInt16.cs
@@ -334,7 +334,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -342,7 +342,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -374,9 +379,11 @@ private void ValidateResult(void* left, void* right, void* result, [CallerMember
 
         private void ValidateResult(Byte[] left, Byte[] right, UInt16[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (result[0] != Math.Abs(left[0] - right[0]) + Math.Abs(left[1] - right[1]) + Math.Abs(left[2] - right[2]) + Math.Abs(left[3] - right[3]) + Math.Abs(left[4] - right[4]) + Math.Abs(left[5] - right[5]) + Math.Abs(left[6] - right[6]) + Math.Abs(left[7] - right[7]))
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -384,19 +391,21 @@ private void ValidateResult(Byte[] left, Byte[] right, UInt16[] result, [CallerM
                 {
                     if (result[i] != (i != 4 ? 0 : Math.Abs(left[8] - right[8]) + Math.Abs(left[9] - right[9]) + Math.Abs(left[10] - right[10]) + Math.Abs(left[11] - right[11]) + Math.Abs(left[12] - right[12]) + Math.Abs(left[13] - right[13]) + Math.Abs(left[14] - right[14]) + Math.Abs(left[15] - right[15])))
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Sse2)}.{nameof(Sse2.SumAbsoluteDifferences)}<UInt16>(Vector128<Byte>, Vector128<Byte>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/UnpackHigh.Byte.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/UnpackHigh.Byte.cs
index c2b1de090cee..6afc808082cd 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/UnpackHigh.Byte.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/UnpackHigh.Byte.cs
@@ -334,7 +334,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -342,7 +342,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -374,9 +379,11 @@ private void ValidateResult(void* left, void* right, void* result, [CallerMember
 
         private void ValidateResult(Byte[] left, Byte[] right, Byte[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (result[0] != left[8])
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -384,19 +391,21 @@ private void ValidateResult(Byte[] left, Byte[] right, Byte[] result, [CallerMem
                 {
                     if ((i % 2 == 0) ? result[i] != left[i/2 + 8] : result[i] != right[(i - 1)/2 + 8])
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Sse2)}.{nameof(Sse2.UnpackHigh)}<Byte>(Vector128<Byte>, Vector128<Byte>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/UnpackHigh.Double.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/UnpackHigh.Double.cs
index 04babb54ef5b..f408c847d2ad 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/UnpackHigh.Double.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/UnpackHigh.Double.cs
@@ -334,7 +334,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -342,7 +342,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -374,9 +379,11 @@ private void ValidateResult(void* left, void* right, void* result, [CallerMember
 
         private void ValidateResult(Double[] left, Double[] right, Double[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (BitConverter.DoubleToInt64Bits(result[0]) != BitConverter.DoubleToInt64Bits(left[1]))
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -384,19 +391,21 @@ private void ValidateResult(Double[] left, Double[] right, Double[] result, [Cal
                 {
                     if ((i % 2 == 0) ? BitConverter.DoubleToInt64Bits(result[i]) != BitConverter.DoubleToInt64Bits(left[i/2+1]) : BitConverter.DoubleToInt64Bits(result[i]) != BitConverter.DoubleToInt64Bits(right[(i - 1)/2 + 1]))
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Sse2)}.{nameof(Sse2.UnpackHigh)}<Double>(Vector128<Double>, Vector128<Double>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/UnpackHigh.Int16.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/UnpackHigh.Int16.cs
index ab6dc392c86a..99be8e5258b9 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/UnpackHigh.Int16.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/UnpackHigh.Int16.cs
@@ -334,7 +334,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -342,7 +342,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -374,9 +379,11 @@ private void ValidateResult(void* left, void* right, void* result, [CallerMember
 
         private void ValidateResult(Int16[] left, Int16[] right, Int16[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (result[0] != left[4])
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -384,19 +391,21 @@ private void ValidateResult(Int16[] left, Int16[] right, Int16[] result, [Caller
                 {
                     if ((i % 2 == 0) ? result[i] != left[i/2 + 4] : result[i] != right[(i - 1)/2 + 4])
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Sse2)}.{nameof(Sse2.UnpackHigh)}<Int16>(Vector128<Int16>, Vector128<Int16>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/UnpackHigh.Int32.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/UnpackHigh.Int32.cs
index 4d6994b73074..248ddf596d7e 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/UnpackHigh.Int32.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/UnpackHigh.Int32.cs
@@ -334,7 +334,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -342,7 +342,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -374,9 +379,11 @@ private void ValidateResult(void* left, void* right, void* result, [CallerMember
 
         private void ValidateResult(Int32[] left, Int32[] right, Int32[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (result[0] != left[2])
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -384,19 +391,21 @@ private void ValidateResult(Int32[] left, Int32[] right, Int32[] result, [Caller
                 {
                     if ((i % 2 == 0) ? result[i] != left[i/2 + 2] : result[i] != right[(i - 1)/2 + 2])
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Sse2)}.{nameof(Sse2.UnpackHigh)}<Int32>(Vector128<Int32>, Vector128<Int32>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/UnpackHigh.Int64.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/UnpackHigh.Int64.cs
index 8c6cfca34b9b..65d5a7451bc5 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/UnpackHigh.Int64.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/UnpackHigh.Int64.cs
@@ -334,7 +334,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -342,7 +342,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -374,9 +379,11 @@ private void ValidateResult(void* left, void* right, void* result, [CallerMember
 
         private void ValidateResult(Int64[] left, Int64[] right, Int64[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (result[0] != left[1] || result[1] != right[1])
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -384,19 +391,21 @@ private void ValidateResult(Int64[] left, Int64[] right, Int64[] result, [Caller
                 {
                     if ((i % 2 == 0) ? result[i] != left[i/2 + 1] : result[i] != right[(i - 1)/2 + 1])
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Sse2)}.{nameof(Sse2.UnpackHigh)}<Int64>(Vector128<Int64>, Vector128<Int64>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/UnpackHigh.SByte.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/UnpackHigh.SByte.cs
index 098acf728c36..ceb78be40b49 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/UnpackHigh.SByte.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/UnpackHigh.SByte.cs
@@ -334,7 +334,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -342,7 +342,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -374,9 +379,11 @@ private void ValidateResult(void* left, void* right, void* result, [CallerMember
 
         private void ValidateResult(SByte[] left, SByte[] right, SByte[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (result[0] != left[8])
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -384,19 +391,21 @@ private void ValidateResult(SByte[] left, SByte[] right, SByte[] result, [Caller
                 {
                     if ((i % 2 == 0) ? result[i] != left[i/2 + 8] : result[i] != right[(i - 1)/2 + 8])
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Sse2)}.{nameof(Sse2.UnpackHigh)}<SByte>(Vector128<SByte>, Vector128<SByte>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/UnpackHigh.UInt16.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/UnpackHigh.UInt16.cs
index cc2939ab02f2..f48ea3ac03b3 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/UnpackHigh.UInt16.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/UnpackHigh.UInt16.cs
@@ -334,7 +334,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -342,7 +342,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -374,9 +379,11 @@ private void ValidateResult(void* left, void* right, void* result, [CallerMember
 
         private void ValidateResult(UInt16[] left, UInt16[] right, UInt16[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (result[0] != left[4])
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -384,19 +391,21 @@ private void ValidateResult(UInt16[] left, UInt16[] right, UInt16[] result, [Cal
                 {
                     if ((i % 2 == 0) ? result[i] != left[i/2 + 4] : result[i] != right[(i - 1)/2 + 4])
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Sse2)}.{nameof(Sse2.UnpackHigh)}<UInt16>(Vector128<UInt16>, Vector128<UInt16>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/UnpackHigh.UInt32.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/UnpackHigh.UInt32.cs
index 7ca7a2e9d11e..667d25b8de93 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/UnpackHigh.UInt32.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/UnpackHigh.UInt32.cs
@@ -334,7 +334,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -342,7 +342,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -374,9 +379,11 @@ private void ValidateResult(void* left, void* right, void* result, [CallerMember
 
         private void ValidateResult(UInt32[] left, UInt32[] right, UInt32[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (result[0] != left[2])
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -384,19 +391,21 @@ private void ValidateResult(UInt32[] left, UInt32[] right, UInt32[] result, [Cal
                 {
                     if ((i % 2 == 0) ? result[i] != left[i/2 + 2] : result[i] != right[(i - 1)/2 + 2])
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Sse2)}.{nameof(Sse2.UnpackHigh)}<UInt32>(Vector128<UInt32>, Vector128<UInt32>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/UnpackHigh.UInt64.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/UnpackHigh.UInt64.cs
index 83e0d9236e4d..d704c8d69ab4 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/UnpackHigh.UInt64.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/UnpackHigh.UInt64.cs
@@ -334,7 +334,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -342,7 +342,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -374,9 +379,11 @@ private void ValidateResult(void* left, void* right, void* result, [CallerMember
 
         private void ValidateResult(UInt64[] left, UInt64[] right, UInt64[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (result[0] != left[1] || result[1] != right[1])
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -384,19 +391,21 @@ private void ValidateResult(UInt64[] left, UInt64[] right, UInt64[] result, [Cal
                 {
                     if ((i % 2 == 0) ? result[i] != left[i/2 + 1] : result[i] != right[(i - 1)/2 + 1])
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Sse2)}.{nameof(Sse2.UnpackHigh)}<UInt64>(Vector128<UInt64>, Vector128<UInt64>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/UnpackLow.Byte.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/UnpackLow.Byte.cs
index 4815b01a8a63..ef0aa7b03cea 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/UnpackLow.Byte.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/UnpackLow.Byte.cs
@@ -334,7 +334,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -342,7 +342,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -374,9 +379,11 @@ private void ValidateResult(void* left, void* right, void* result, [CallerMember
 
         private void ValidateResult(Byte[] left, Byte[] right, Byte[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (result[0] != left[0])
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -384,19 +391,21 @@ private void ValidateResult(Byte[] left, Byte[] right, Byte[] result, [CallerMem
                 {
                     if ((i % 2 == 0) ? result[i] != left[i/2] : result[i] != right[(i - 1)/2])
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Sse2)}.{nameof(Sse2.UnpackLow)}<Byte>(Vector128<Byte>, Vector128<Byte>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/UnpackLow.Double.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/UnpackLow.Double.cs
index 82879249cd7b..9bdbc57eb32a 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/UnpackLow.Double.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/UnpackLow.Double.cs
@@ -334,7 +334,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -342,7 +342,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -374,9 +379,11 @@ private void ValidateResult(void* left, void* right, void* result, [CallerMember
 
         private void ValidateResult(Double[] left, Double[] right, Double[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (BitConverter.DoubleToInt64Bits(result[0]) != BitConverter.DoubleToInt64Bits(left[0]))
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -384,19 +391,21 @@ private void ValidateResult(Double[] left, Double[] right, Double[] result, [Cal
                 {
                     if ((i % 2 == 0) ? BitConverter.DoubleToInt64Bits(result[i]) != BitConverter.DoubleToInt64Bits(left[i/2]) : BitConverter.DoubleToInt64Bits(result[i]) != BitConverter.DoubleToInt64Bits(right[(i - 1)/2]))
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Sse2)}.{nameof(Sse2.UnpackLow)}<Double>(Vector128<Double>, Vector128<Double>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/UnpackLow.Int16.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/UnpackLow.Int16.cs
index 97b939bcb9c8..f75351b73243 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/UnpackLow.Int16.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/UnpackLow.Int16.cs
@@ -334,7 +334,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -342,7 +342,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -374,9 +379,11 @@ private void ValidateResult(void* left, void* right, void* result, [CallerMember
 
         private void ValidateResult(Int16[] left, Int16[] right, Int16[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (result[0] != left[0])
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -384,19 +391,21 @@ private void ValidateResult(Int16[] left, Int16[] right, Int16[] result, [Caller
                 {
                     if ((i % 2 == 0) ? result[i] != left[i/2] : result[i] != right[(i - 1)/2])
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Sse2)}.{nameof(Sse2.UnpackLow)}<Int16>(Vector128<Int16>, Vector128<Int16>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/UnpackLow.Int32.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/UnpackLow.Int32.cs
index f31b3418ceeb..fb17d0d7c539 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/UnpackLow.Int32.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/UnpackLow.Int32.cs
@@ -334,7 +334,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -342,7 +342,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -374,9 +379,11 @@ private void ValidateResult(void* left, void* right, void* result, [CallerMember
 
         private void ValidateResult(Int32[] left, Int32[] right, Int32[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (result[0] != left[0])
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -384,19 +391,21 @@ private void ValidateResult(Int32[] left, Int32[] right, Int32[] result, [Caller
                 {
                     if ((i % 2 == 0) ? result[i] != left[i/2] : result[i] != right[(i - 1)/2])
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Sse2)}.{nameof(Sse2.UnpackLow)}<Int32>(Vector128<Int32>, Vector128<Int32>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/UnpackLow.Int64.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/UnpackLow.Int64.cs
index 8cd4d81be1e9..01a2dddcc462 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/UnpackLow.Int64.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/UnpackLow.Int64.cs
@@ -334,7 +334,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -342,7 +342,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -374,9 +379,11 @@ private void ValidateResult(void* left, void* right, void* result, [CallerMember
 
         private void ValidateResult(Int64[] left, Int64[] right, Int64[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (result[0] != left[0] || result[1] != right[0])
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -384,19 +391,21 @@ private void ValidateResult(Int64[] left, Int64[] right, Int64[] result, [Caller
                 {
                     if ((i % 2 == 0) ? result[i] != left[i/2] : result[i] != right[(i - 1)/2])
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Sse2)}.{nameof(Sse2.UnpackLow)}<Int64>(Vector128<Int64>, Vector128<Int64>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/UnpackLow.SByte.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/UnpackLow.SByte.cs
index 77a11e24bf21..6bd4c74fab58 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/UnpackLow.SByte.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/UnpackLow.SByte.cs
@@ -334,7 +334,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -342,7 +342,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -374,9 +379,11 @@ private void ValidateResult(void* left, void* right, void* result, [CallerMember
 
         private void ValidateResult(SByte[] left, SByte[] right, SByte[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (result[0] != left[0])
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -384,19 +391,21 @@ private void ValidateResult(SByte[] left, SByte[] right, SByte[] result, [Caller
                 {
                     if ((i % 2 == 0) ? result[i] != left[i/2] : result[i] != right[(i - 1)/2])
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Sse2)}.{nameof(Sse2.UnpackLow)}<SByte>(Vector128<SByte>, Vector128<SByte>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/UnpackLow.UInt16.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/UnpackLow.UInt16.cs
index 0cbe160003c8..c921cc83bc0d 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/UnpackLow.UInt16.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/UnpackLow.UInt16.cs
@@ -334,7 +334,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -342,7 +342,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -374,9 +379,11 @@ private void ValidateResult(void* left, void* right, void* result, [CallerMember
 
         private void ValidateResult(UInt16[] left, UInt16[] right, UInt16[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (result[0] != left[0])
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -384,19 +391,21 @@ private void ValidateResult(UInt16[] left, UInt16[] right, UInt16[] result, [Cal
                 {
                     if ((i % 2 == 0) ? result[i] != left[i/2] : result[i] != right[(i - 1)/2])
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Sse2)}.{nameof(Sse2.UnpackLow)}<UInt16>(Vector128<UInt16>, Vector128<UInt16>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/UnpackLow.UInt32.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/UnpackLow.UInt32.cs
index 420afbb74006..d5696e889545 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/UnpackLow.UInt32.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/UnpackLow.UInt32.cs
@@ -334,7 +334,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -342,7 +342,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -374,9 +379,11 @@ private void ValidateResult(void* left, void* right, void* result, [CallerMember
 
         private void ValidateResult(UInt32[] left, UInt32[] right, UInt32[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (result[0] != left[0])
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -384,19 +391,21 @@ private void ValidateResult(UInt32[] left, UInt32[] right, UInt32[] result, [Cal
                 {
                     if ((i % 2 == 0) ? result[i] != left[i/2] : result[i] != right[(i - 1)/2])
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Sse2)}.{nameof(Sse2.UnpackLow)}<UInt32>(Vector128<UInt32>, Vector128<UInt32>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/UnpackLow.UInt64.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/UnpackLow.UInt64.cs
index 756c03edf4eb..fe554a16eef7 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/UnpackLow.UInt64.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/UnpackLow.UInt64.cs
@@ -334,7 +334,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -342,7 +342,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -374,9 +379,11 @@ private void ValidateResult(void* left, void* right, void* result, [CallerMember
 
         private void ValidateResult(UInt64[] left, UInt64[] right, UInt64[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (result[0] != left[0] || result[1] != right[0])
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -384,19 +391,21 @@ private void ValidateResult(UInt64[] left, UInt64[] right, UInt64[] result, [Cal
                 {
                     if ((i % 2 == 0) ? result[i] != left[i/2] : result[i] != right[(i - 1)/2])
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Sse2)}.{nameof(Sse2.UnpackLow)}<UInt64>(Vector128<UInt64>, Vector128<UInt64>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/Xor.Byte.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/Xor.Byte.cs
index b5e4e8556b0e..251499f8c0a6 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/Xor.Byte.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/Xor.Byte.cs
@@ -334,7 +334,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -342,7 +342,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -374,9 +379,11 @@ private void ValidateResult(void* left, void* right, void* result, [CallerMember
 
         private void ValidateResult(Byte[] left, Byte[] right, Byte[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if ((byte)(left[0] ^ right[0]) != result[0])
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -384,19 +391,21 @@ private void ValidateResult(Byte[] left, Byte[] right, Byte[] result, [CallerMem
                 {
                     if ((byte)(left[i] ^ right[i]) != result[i])
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Sse2)}.{nameof(Sse2.Xor)}<Byte>(Vector128<Byte>, Vector128<Byte>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/Xor.Double.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/Xor.Double.cs
index 2212c2474e9a..2573fde58478 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/Xor.Double.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/Xor.Double.cs
@@ -334,7 +334,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -342,7 +342,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -374,9 +379,11 @@ private void ValidateResult(void* left, void* right, void* result, [CallerMember
 
         private void ValidateResult(Double[] left, Double[] right, Double[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if ((BitConverter.DoubleToInt64Bits(left[0]) ^ BitConverter.DoubleToInt64Bits(right[0])) != BitConverter.DoubleToInt64Bits(result[0]))
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -384,19 +391,21 @@ private void ValidateResult(Double[] left, Double[] right, Double[] result, [Cal
                 {
                     if ((BitConverter.DoubleToInt64Bits(left[i]) ^ BitConverter.DoubleToInt64Bits(right[i])) != BitConverter.DoubleToInt64Bits(result[i]))
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Sse2)}.{nameof(Sse2.Xor)}<Double>(Vector128<Double>, Vector128<Double>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/Xor.Int16.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/Xor.Int16.cs
index 78a4881ae35b..5e298aed4f4c 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/Xor.Int16.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/Xor.Int16.cs
@@ -334,7 +334,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -342,7 +342,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -374,9 +379,11 @@ private void ValidateResult(void* left, void* right, void* result, [CallerMember
 
         private void ValidateResult(Int16[] left, Int16[] right, Int16[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if ((short)(left[0] ^ right[0]) != result[0])
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -384,19 +391,21 @@ private void ValidateResult(Int16[] left, Int16[] right, Int16[] result, [Caller
                 {
                     if ((short)(left[i] ^ right[i]) != result[i])
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Sse2)}.{nameof(Sse2.Xor)}<Int16>(Vector128<Int16>, Vector128<Int16>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/Xor.Int32.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/Xor.Int32.cs
index 3e54a28b6a41..5d20fad35628 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/Xor.Int32.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/Xor.Int32.cs
@@ -334,7 +334,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -342,7 +342,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -374,9 +379,11 @@ private void ValidateResult(void* left, void* right, void* result, [CallerMember
 
         private void ValidateResult(Int32[] left, Int32[] right, Int32[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if ((int)(left[0] ^ right[0]) != result[0])
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -384,19 +391,21 @@ private void ValidateResult(Int32[] left, Int32[] right, Int32[] result, [Caller
                 {
                     if ((int)(left[i] ^ right[i]) != result[i])
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Sse2)}.{nameof(Sse2.Xor)}<Int32>(Vector128<Int32>, Vector128<Int32>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/Xor.Int64.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/Xor.Int64.cs
index 859aab8d0e2f..e3131f757cfc 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/Xor.Int64.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/Xor.Int64.cs
@@ -334,7 +334,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -342,7 +342,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -374,9 +379,11 @@ private void ValidateResult(void* left, void* right, void* result, [CallerMember
 
         private void ValidateResult(Int64[] left, Int64[] right, Int64[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if ((long)(left[0] ^ right[0]) != result[0])
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -384,19 +391,21 @@ private void ValidateResult(Int64[] left, Int64[] right, Int64[] result, [Caller
                 {
                     if ((long)(left[i] ^ right[i]) != result[i])
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Sse2)}.{nameof(Sse2.Xor)}<Int64>(Vector128<Int64>, Vector128<Int64>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/Xor.SByte.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/Xor.SByte.cs
index 685a96c458d9..cf8fabf052c4 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/Xor.SByte.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/Xor.SByte.cs
@@ -334,7 +334,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -342,7 +342,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -374,9 +379,11 @@ private void ValidateResult(void* left, void* right, void* result, [CallerMember
 
         private void ValidateResult(SByte[] left, SByte[] right, SByte[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if ((sbyte)(left[0] ^ right[0]) != result[0])
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -384,19 +391,21 @@ private void ValidateResult(SByte[] left, SByte[] right, SByte[] result, [Caller
                 {
                     if ((sbyte)(left[i] ^ right[i]) != result[i])
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Sse2)}.{nameof(Sse2.Xor)}<SByte>(Vector128<SByte>, Vector128<SByte>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/Xor.UInt16.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/Xor.UInt16.cs
index 13cde1910e06..61766a29350a 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/Xor.UInt16.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/Xor.UInt16.cs
@@ -334,7 +334,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -342,7 +342,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -374,9 +379,11 @@ private void ValidateResult(void* left, void* right, void* result, [CallerMember
 
         private void ValidateResult(UInt16[] left, UInt16[] right, UInt16[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if ((ushort)(left[0] ^ right[0]) != result[0])
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -384,19 +391,21 @@ private void ValidateResult(UInt16[] left, UInt16[] right, UInt16[] result, [Cal
                 {
                     if ((ushort)(left[i] ^ right[i]) != result[i])
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Sse2)}.{nameof(Sse2.Xor)}<UInt16>(Vector128<UInt16>, Vector128<UInt16>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/Xor.UInt32.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/Xor.UInt32.cs
index 11fc8adddec5..92443629b803 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/Xor.UInt32.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/Xor.UInt32.cs
@@ -334,7 +334,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -342,7 +342,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -374,9 +379,11 @@ private void ValidateResult(void* left, void* right, void* result, [CallerMember
 
         private void ValidateResult(UInt32[] left, UInt32[] right, UInt32[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if ((uint)(left[0] ^ right[0]) != result[0])
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -384,19 +391,21 @@ private void ValidateResult(UInt32[] left, UInt32[] right, UInt32[] result, [Cal
                 {
                     if ((uint)(left[i] ^ right[i]) != result[i])
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Sse2)}.{nameof(Sse2.Xor)}<UInt32>(Vector128<UInt32>, Vector128<UInt32>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/Xor.UInt64.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/Xor.UInt64.cs
index fff6e3efb9d0..827e31c8de76 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/Xor.UInt64.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/Xor.UInt64.cs
@@ -334,7 +334,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -342,7 +342,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -374,9 +379,11 @@ private void ValidateResult(void* left, void* right, void* result, [CallerMember
 
         private void ValidateResult(UInt64[] left, UInt64[] right, UInt64[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if ((ulong)(left[0] ^ right[0]) != result[0])
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -384,19 +391,21 @@ private void ValidateResult(UInt64[] left, UInt64[] right, UInt64[] result, [Cal
                 {
                     if ((ulong)(left[i] ^ right[i]) != result[i])
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Sse2)}.{nameof(Sse2.Xor)}<UInt64>(Vector128<UInt64>, Vector128<UInt64>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse3/AddSubtract.Double.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse3/AddSubtract.Double.cs
index 4044a273cd71..654ef64453b6 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Sse3/AddSubtract.Double.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse3/AddSubtract.Double.cs
@@ -334,7 +334,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -342,7 +342,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -374,28 +379,32 @@ private void ValidateResult(void* left, void* right, void* result, [CallerMember
 
         private void ValidateResult(Double[] left, Double[] right, Double[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             for (var i = 0; i < RetElementCount; i += 2)
             {
                 if (BitConverter.DoubleToInt64Bits(result[i]) != BitConverter.DoubleToInt64Bits(left[i] - right[i]))
                 {
-                    Succeeded = false;
+                    succeeded = false;
                     break;
                 }
 
                 if (BitConverter.DoubleToInt64Bits(result[i + 1]) != BitConverter.DoubleToInt64Bits(left[i + 1] + right[i + 1]))
                 {
-                    Succeeded = false;
+                    succeeded = false;
                     break;
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Sse3)}.{nameof(Sse3.AddSubtract)}<Double>(Vector128<Double>, Vector128<Double>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse3/AddSubtract.Single.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse3/AddSubtract.Single.cs
index 3020220b3b68..0b0781129469 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Sse3/AddSubtract.Single.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse3/AddSubtract.Single.cs
@@ -334,7 +334,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -342,7 +342,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -374,28 +379,32 @@ private void ValidateResult(void* left, void* right, void* result, [CallerMember
 
         private void ValidateResult(Single[] left, Single[] right, Single[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             for (var i = 0; i < RetElementCount; i += 2)
             {
                 if (BitConverter.SingleToInt32Bits(result[i]) != BitConverter.SingleToInt32Bits(left[i] - right[i]))
                 {
-                    Succeeded = false;
+                    succeeded = false;
                     break;
                 }
 
                 if (BitConverter.SingleToInt32Bits(result[i + 1]) != BitConverter.SingleToInt32Bits(left[i + 1] + right[i + 1]))
                 {
-                    Succeeded = false;
+                    succeeded = false;
                     break;
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Sse3)}.{nameof(Sse3.AddSubtract)}<Single>(Vector128<Single>, Vector128<Single>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse3/HorizontalAdd.Double.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse3/HorizontalAdd.Double.cs
index 206c2678a2ef..38917133cd7e 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Sse3/HorizontalAdd.Double.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse3/HorizontalAdd.Double.cs
@@ -334,7 +334,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -342,7 +342,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -374,6 +379,8 @@ private void ValidateResult(void* left, void* right, void* result, [CallerMember
 
         private void ValidateResult(Double[] left, Double[] right, Double[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             for (var outer = 0; outer < (LargestVectorSize / 16); outer++)
             {
                 for (var inner = 0; inner < (8 / sizeof(Double)); inner++)
@@ -384,25 +391,27 @@ private void ValidateResult(Double[] left, Double[] right, Double[] result, [Cal
 
                     if (BitConverter.DoubleToInt64Bits(result[i1]) != BitConverter.DoubleToInt64Bits(left[i3] + left[i3 + 1]))
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
 
                     if (BitConverter.DoubleToInt64Bits(result[i2]) != BitConverter.DoubleToInt64Bits(right[i3] + right[i3 + 1]))
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Sse3)}.{nameof(Sse3.HorizontalAdd)}<Double>(Vector128<Double>, Vector128<Double>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse3/HorizontalAdd.Single.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse3/HorizontalAdd.Single.cs
index a28c1b97d6af..10b76a4888a3 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Sse3/HorizontalAdd.Single.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse3/HorizontalAdd.Single.cs
@@ -334,7 +334,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -342,7 +342,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -374,6 +379,8 @@ private void ValidateResult(void* left, void* right, void* result, [CallerMember
 
         private void ValidateResult(Single[] left, Single[] right, Single[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             for (var outer = 0; outer < (LargestVectorSize / 16); outer++)
             {
                 for (var inner = 0; inner < (8 / sizeof(Single)); inner++)
@@ -384,25 +391,27 @@ private void ValidateResult(Single[] left, Single[] right, Single[] result, [Cal
 
                     if (BitConverter.SingleToInt32Bits(result[i1]) != BitConverter.SingleToInt32Bits(left[i3] + left[i3 + 1]))
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
 
                     if (BitConverter.SingleToInt32Bits(result[i2]) != BitConverter.SingleToInt32Bits(right[i3] + right[i3 + 1]))
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Sse3)}.{nameof(Sse3.HorizontalAdd)}<Single>(Vector128<Single>, Vector128<Single>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse3/HorizontalSubtract.Double.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse3/HorizontalSubtract.Double.cs
index 4629c3ba275f..04299dacd095 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Sse3/HorizontalSubtract.Double.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse3/HorizontalSubtract.Double.cs
@@ -334,7 +334,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -342,7 +342,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -374,6 +379,8 @@ private void ValidateResult(void* left, void* right, void* result, [CallerMember
 
         private void ValidateResult(Double[] left, Double[] right, Double[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             for (var outer = 0; outer < (LargestVectorSize / 16); outer++)
             {
                 for (var inner = 0; inner < (8 / sizeof(Double)); inner++)
@@ -384,25 +391,27 @@ private void ValidateResult(Double[] left, Double[] right, Double[] result, [Cal
 
                     if (BitConverter.DoubleToInt64Bits(result[i1]) != BitConverter.DoubleToInt64Bits(left[i3] - left[i3 + 1]))
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
 
                     if (BitConverter.DoubleToInt64Bits(result[i2]) != BitConverter.DoubleToInt64Bits(right[i3] - right[i3 + 1]))
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Sse3)}.{nameof(Sse3.HorizontalSubtract)}<Double>(Vector128<Double>, Vector128<Double>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse3/HorizontalSubtract.Single.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse3/HorizontalSubtract.Single.cs
index 25ad60b6bf9d..9cfa01ee46b5 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Sse3/HorizontalSubtract.Single.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse3/HorizontalSubtract.Single.cs
@@ -334,7 +334,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -342,7 +342,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -374,6 +379,8 @@ private void ValidateResult(void* left, void* right, void* result, [CallerMember
 
         private void ValidateResult(Single[] left, Single[] right, Single[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             for (var outer = 0; outer < (LargestVectorSize / 16); outer++)
             {
                 for (var inner = 0; inner < (8 / sizeof(Single)); inner++)
@@ -384,25 +391,27 @@ private void ValidateResult(Single[] left, Single[] right, Single[] result, [Cal
 
                     if (BitConverter.SingleToInt32Bits(result[i1]) != BitConverter.SingleToInt32Bits(left[i3] - left[i3 + 1]))
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
 
                     if (BitConverter.SingleToInt32Bits(result[i2]) != BitConverter.SingleToInt32Bits(right[i3] - right[i3 + 1]))
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Sse3)}.{nameof(Sse3.HorizontalSubtract)}<Single>(Vector128<Single>, Vector128<Single>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/BlendVariable.Byte.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/BlendVariable.Byte.cs
index eedee7d6438a..086b6f2a14e1 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/BlendVariable.Byte.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/BlendVariable.Byte.cs
@@ -356,7 +356,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -364,7 +364,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -400,9 +405,11 @@ private void ValidateResult(void* firstOp, void* secondOp, void* thirdOp, void*
 
         private void ValidateResult(Byte[] firstOp, Byte[] secondOp, Byte[] thirdOp, Byte[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (((thirdOp[0] >> 7) & 1) == 1 ? secondOp[0] != result[0] : firstOp[0] != result[0])
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -410,13 +417,13 @@ private void ValidateResult(Byte[] firstOp, Byte[] secondOp, Byte[] thirdOp, Byt
                 {
                     if (((thirdOp[i] >> 7) & 1) == 1 ? secondOp[i] != result[i] : firstOp[i] != result[i])
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Sse41)}.{nameof(Sse41.BlendVariable)}<Byte>(Vector128<Byte>, Vector128<Byte>, Vector128<Byte>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"   firstOp: ({string.Join(", ", firstOp)})");
@@ -424,6 +431,8 @@ private void ValidateResult(Byte[] firstOp, Byte[] secondOp, Byte[] thirdOp, Byt
                 TestLibrary.TestFramework.LogInformation($"   thirdOp: ({string.Join(", ", thirdOp)})");
                 TestLibrary.TestFramework.LogInformation($"    result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/BlendVariable.Double.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/BlendVariable.Double.cs
index c72411084427..ba2c454f1a8b 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/BlendVariable.Double.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/BlendVariable.Double.cs
@@ -356,7 +356,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -364,7 +364,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -400,9 +405,11 @@ private void ValidateResult(void* firstOp, void* secondOp, void* thirdOp, void*
 
         private void ValidateResult(Double[] firstOp, Double[] secondOp, Double[] thirdOp, Double[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (((BitConverter.DoubleToInt64Bits(thirdOp[0]) >> 63) & 1) == 1 ? BitConverter.DoubleToInt64Bits(secondOp[0]) != BitConverter.DoubleToInt64Bits(result[0]) : BitConverter.DoubleToInt64Bits(firstOp[0]) != BitConverter.DoubleToInt64Bits(result[0]))
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -410,13 +417,13 @@ private void ValidateResult(Double[] firstOp, Double[] secondOp, Double[] thirdO
                 {
                     if (((BitConverter.DoubleToInt64Bits(thirdOp[i]) >> 63) & 1) == 1 ? BitConverter.DoubleToInt64Bits(secondOp[i]) != BitConverter.DoubleToInt64Bits(result[i]) : BitConverter.DoubleToInt64Bits(firstOp[i]) != BitConverter.DoubleToInt64Bits(result[i]))
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Sse41)}.{nameof(Sse41.BlendVariable)}<Double>(Vector128<Double>, Vector128<Double>, Vector128<Double>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"   firstOp: ({string.Join(", ", firstOp)})");
@@ -424,6 +431,8 @@ private void ValidateResult(Double[] firstOp, Double[] secondOp, Double[] thirdO
                 TestLibrary.TestFramework.LogInformation($"   thirdOp: ({string.Join(", ", thirdOp)})");
                 TestLibrary.TestFramework.LogInformation($"    result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/BlendVariable.Int16.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/BlendVariable.Int16.cs
index 51d3a38757d8..642e55bf6b29 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/BlendVariable.Int16.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/BlendVariable.Int16.cs
@@ -356,7 +356,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -364,7 +364,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -400,9 +405,11 @@ private void ValidateResult(void* firstOp, void* secondOp, void* thirdOp, void*
 
         private void ValidateResult(Int16[] firstOp, Int16[] secondOp, Int16[] thirdOp, Int16[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if ((thirdOp[0] != 0) ? secondOp[0] != result[0] : firstOp[0] != result[0])
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -410,13 +417,13 @@ private void ValidateResult(Int16[] firstOp, Int16[] secondOp, Int16[] thirdOp,
                 {
                     if ((thirdOp[i] != 0) ? secondOp[i] != result[i] : firstOp[i] != result[i])
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Sse41)}.{nameof(Sse41.BlendVariable)}<Int16>(Vector128<Int16>, Vector128<Int16>, Vector128<Int16>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"   firstOp: ({string.Join(", ", firstOp)})");
@@ -424,6 +431,8 @@ private void ValidateResult(Int16[] firstOp, Int16[] secondOp, Int16[] thirdOp,
                 TestLibrary.TestFramework.LogInformation($"   thirdOp: ({string.Join(", ", thirdOp)})");
                 TestLibrary.TestFramework.LogInformation($"    result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/BlendVariable.Int32.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/BlendVariable.Int32.cs
index 1fcb6fc988d9..907e84989fd2 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/BlendVariable.Int32.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/BlendVariable.Int32.cs
@@ -356,7 +356,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -364,7 +364,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -400,9 +405,11 @@ private void ValidateResult(void* firstOp, void* secondOp, void* thirdOp, void*
 
         private void ValidateResult(Int32[] firstOp, Int32[] secondOp, Int32[] thirdOp, Int32[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if ((thirdOp[0] != 0) ? secondOp[0] != result[0] : firstOp[0] != result[0])
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -410,13 +417,13 @@ private void ValidateResult(Int32[] firstOp, Int32[] secondOp, Int32[] thirdOp,
                 {
                     if ((thirdOp[i] != 0) ? secondOp[i] != result[i] : firstOp[i] != result[i])
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Sse41)}.{nameof(Sse41.BlendVariable)}<Int32>(Vector128<Int32>, Vector128<Int32>, Vector128<Int32>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"   firstOp: ({string.Join(", ", firstOp)})");
@@ -424,6 +431,8 @@ private void ValidateResult(Int32[] firstOp, Int32[] secondOp, Int32[] thirdOp,
                 TestLibrary.TestFramework.LogInformation($"   thirdOp: ({string.Join(", ", thirdOp)})");
                 TestLibrary.TestFramework.LogInformation($"    result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/BlendVariable.Int64.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/BlendVariable.Int64.cs
index 3f72e11a05fc..e6b453178799 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/BlendVariable.Int64.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/BlendVariable.Int64.cs
@@ -356,7 +356,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -364,7 +364,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -400,9 +405,11 @@ private void ValidateResult(void* firstOp, void* secondOp, void* thirdOp, void*
 
         private void ValidateResult(Int64[] firstOp, Int64[] secondOp, Int64[] thirdOp, Int64[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if ((thirdOp[0] != 0) ? secondOp[0] != result[0] : firstOp[0] != result[0])
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -410,13 +417,13 @@ private void ValidateResult(Int64[] firstOp, Int64[] secondOp, Int64[] thirdOp,
                 {
                     if ((thirdOp[i] != 0) ? secondOp[i] != result[i] : firstOp[i] != result[i])
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Sse41)}.{nameof(Sse41.BlendVariable)}<Int64>(Vector128<Int64>, Vector128<Int64>, Vector128<Int64>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"   firstOp: ({string.Join(", ", firstOp)})");
@@ -424,6 +431,8 @@ private void ValidateResult(Int64[] firstOp, Int64[] secondOp, Int64[] thirdOp,
                 TestLibrary.TestFramework.LogInformation($"   thirdOp: ({string.Join(", ", thirdOp)})");
                 TestLibrary.TestFramework.LogInformation($"    result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/BlendVariable.SByte.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/BlendVariable.SByte.cs
index 88204104a2e1..80674e40c598 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/BlendVariable.SByte.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/BlendVariable.SByte.cs
@@ -356,7 +356,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -364,7 +364,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -400,9 +405,11 @@ private void ValidateResult(void* firstOp, void* secondOp, void* thirdOp, void*
 
         private void ValidateResult(SByte[] firstOp, SByte[] secondOp, SByte[] thirdOp, SByte[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (((thirdOp[0] >> 7) & 1) == 1 ? secondOp[0] != result[0] : firstOp[0] != result[0])
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -410,13 +417,13 @@ private void ValidateResult(SByte[] firstOp, SByte[] secondOp, SByte[] thirdOp,
                 {
                     if (((thirdOp[i] >> 7) & 1) == 1 ? secondOp[i] != result[i] : firstOp[i] != result[i])
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Sse41)}.{nameof(Sse41.BlendVariable)}<SByte>(Vector128<SByte>, Vector128<SByte>, Vector128<SByte>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"   firstOp: ({string.Join(", ", firstOp)})");
@@ -424,6 +431,8 @@ private void ValidateResult(SByte[] firstOp, SByte[] secondOp, SByte[] thirdOp,
                 TestLibrary.TestFramework.LogInformation($"   thirdOp: ({string.Join(", ", thirdOp)})");
                 TestLibrary.TestFramework.LogInformation($"    result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/BlendVariable.Single.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/BlendVariable.Single.cs
index e0ec36d59edc..5e8893ba202f 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/BlendVariable.Single.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/BlendVariable.Single.cs
@@ -356,7 +356,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -364,7 +364,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -400,9 +405,11 @@ private void ValidateResult(void* firstOp, void* secondOp, void* thirdOp, void*
 
         private void ValidateResult(Single[] firstOp, Single[] secondOp, Single[] thirdOp, Single[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (((BitConverter.SingleToInt32Bits(thirdOp[0]) >> 31) & 1) == 1 ? BitConverter.SingleToInt32Bits(secondOp[0]) != BitConverter.SingleToInt32Bits(result[0]) : BitConverter.SingleToInt32Bits(firstOp[0]) != BitConverter.SingleToInt32Bits(result[0]))
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -410,13 +417,13 @@ private void ValidateResult(Single[] firstOp, Single[] secondOp, Single[] thirdO
                 {
                     if (((BitConverter.SingleToInt32Bits(thirdOp[i]) >> 31) & 1) == 1 ? BitConverter.SingleToInt32Bits(secondOp[i]) != BitConverter.SingleToInt32Bits(result[i]) : BitConverter.SingleToInt32Bits(firstOp[i]) != BitConverter.SingleToInt32Bits(result[i]))
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Sse41)}.{nameof(Sse41.BlendVariable)}<Single>(Vector128<Single>, Vector128<Single>, Vector128<Single>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"   firstOp: ({string.Join(", ", firstOp)})");
@@ -424,6 +431,8 @@ private void ValidateResult(Single[] firstOp, Single[] secondOp, Single[] thirdO
                 TestLibrary.TestFramework.LogInformation($"   thirdOp: ({string.Join(", ", thirdOp)})");
                 TestLibrary.TestFramework.LogInformation($"    result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/BlendVariable.UInt16.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/BlendVariable.UInt16.cs
index fb85c992602d..8a9064723420 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/BlendVariable.UInt16.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/BlendVariable.UInt16.cs
@@ -356,7 +356,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -364,7 +364,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -400,9 +405,11 @@ private void ValidateResult(void* firstOp, void* secondOp, void* thirdOp, void*
 
         private void ValidateResult(UInt16[] firstOp, UInt16[] secondOp, UInt16[] thirdOp, UInt16[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if ((thirdOp[0] != 0) ? secondOp[0] != result[0] : firstOp[0] != result[0])
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -410,13 +417,13 @@ private void ValidateResult(UInt16[] firstOp, UInt16[] secondOp, UInt16[] thirdO
                 {
                     if ((thirdOp[i] != 0) ? secondOp[i] != result[i] : firstOp[i] != result[i])
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Sse41)}.{nameof(Sse41.BlendVariable)}<UInt16>(Vector128<UInt16>, Vector128<UInt16>, Vector128<UInt16>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"   firstOp: ({string.Join(", ", firstOp)})");
@@ -424,6 +431,8 @@ private void ValidateResult(UInt16[] firstOp, UInt16[] secondOp, UInt16[] thirdO
                 TestLibrary.TestFramework.LogInformation($"   thirdOp: ({string.Join(", ", thirdOp)})");
                 TestLibrary.TestFramework.LogInformation($"    result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/BlendVariable.UInt32.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/BlendVariable.UInt32.cs
index 7e0e95fdcf69..a83b0165415c 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/BlendVariable.UInt32.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/BlendVariable.UInt32.cs
@@ -356,7 +356,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -364,7 +364,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -400,9 +405,11 @@ private void ValidateResult(void* firstOp, void* secondOp, void* thirdOp, void*
 
         private void ValidateResult(UInt32[] firstOp, UInt32[] secondOp, UInt32[] thirdOp, UInt32[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if ((thirdOp[0] != 0) ? secondOp[0] != result[0] : firstOp[0] != result[0])
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -410,13 +417,13 @@ private void ValidateResult(UInt32[] firstOp, UInt32[] secondOp, UInt32[] thirdO
                 {
                     if ((thirdOp[i] != 0) ? secondOp[i] != result[i] : firstOp[i] != result[i])
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Sse41)}.{nameof(Sse41.BlendVariable)}<UInt32>(Vector128<UInt32>, Vector128<UInt32>, Vector128<UInt32>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"   firstOp: ({string.Join(", ", firstOp)})");
@@ -424,6 +431,8 @@ private void ValidateResult(UInt32[] firstOp, UInt32[] secondOp, UInt32[] thirdO
                 TestLibrary.TestFramework.LogInformation($"   thirdOp: ({string.Join(", ", thirdOp)})");
                 TestLibrary.TestFramework.LogInformation($"    result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/BlendVariable.UInt64.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/BlendVariable.UInt64.cs
index d75d21c270d5..b3cf1d428d80 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/BlendVariable.UInt64.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/BlendVariable.UInt64.cs
@@ -356,7 +356,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -364,7 +364,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -400,9 +405,11 @@ private void ValidateResult(void* firstOp, void* secondOp, void* thirdOp, void*
 
         private void ValidateResult(UInt64[] firstOp, UInt64[] secondOp, UInt64[] thirdOp, UInt64[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if ((thirdOp[0] != 0) ? secondOp[0] != result[0] : firstOp[0] != result[0])
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -410,13 +417,13 @@ private void ValidateResult(UInt64[] firstOp, UInt64[] secondOp, UInt64[] thirdO
                 {
                     if ((thirdOp[i] != 0) ? secondOp[i] != result[i] : firstOp[i] != result[i])
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Sse41)}.{nameof(Sse41.BlendVariable)}<UInt64>(Vector128<UInt64>, Vector128<UInt64>, Vector128<UInt64>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"   firstOp: ({string.Join(", ", firstOp)})");
@@ -424,6 +431,8 @@ private void ValidateResult(UInt64[] firstOp, UInt64[] secondOp, UInt64[] thirdO
                 TestLibrary.TestFramework.LogInformation($"   thirdOp: ({string.Join(", ", thirdOp)})");
                 TestLibrary.TestFramework.LogInformation($"    result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/Ceiling.Double.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/Ceiling.Double.cs
index 48f534a03666..86ab3a0d9ad5 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/Ceiling.Double.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/Ceiling.Double.cs
@@ -312,7 +312,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -320,7 +320,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -348,9 +353,11 @@ private void ValidateResult(void* firstOp, void* result, [CallerMemberName] stri
 
         private void ValidateResult(Double[] firstOp, Double[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (BitConverter.DoubleToInt64Bits(result[0]) != BitConverter.DoubleToInt64Bits(Math.Ceiling(firstOp[0])))
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -358,18 +365,20 @@ private void ValidateResult(Double[] firstOp, Double[] result, [CallerMemberName
                 {
                     if (BitConverter.DoubleToInt64Bits(result[i]) != BitConverter.DoubleToInt64Bits(Math.Ceiling(firstOp[i])))
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Sse41)}.{nameof(Sse41.Ceiling)}<Double>(Vector128<Double>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"  firstOp: ({string.Join(", ", firstOp)})");
                 TestLibrary.TestFramework.LogInformation($"   result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/Ceiling.Single.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/Ceiling.Single.cs
index 0a512713c337..15d2128ec34c 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/Ceiling.Single.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/Ceiling.Single.cs
@@ -312,7 +312,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -320,7 +320,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -348,9 +353,11 @@ private void ValidateResult(void* firstOp, void* result, [CallerMemberName] stri
 
         private void ValidateResult(Single[] firstOp, Single[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (BitConverter.SingleToInt32Bits(result[0]) != BitConverter.SingleToInt32Bits(MathF.Ceiling(firstOp[0])))
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -358,18 +365,20 @@ private void ValidateResult(Single[] firstOp, Single[] result, [CallerMemberName
                 {
                     if (BitConverter.SingleToInt32Bits(result[i]) != BitConverter.SingleToInt32Bits(MathF.Ceiling(firstOp[i])))
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Sse41)}.{nameof(Sse41.Ceiling)}<Single>(Vector128<Single>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"  firstOp: ({string.Join(", ", firstOp)})");
                 TestLibrary.TestFramework.LogInformation($"   result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/CeilingScalar.Double.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/CeilingScalar.Double.cs
index 6584b856138f..364f3f7b6571 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/CeilingScalar.Double.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/CeilingScalar.Double.cs
@@ -334,7 +334,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -342,7 +342,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -374,9 +379,11 @@ private void ValidateResult(void* left, void* right, void* result, [CallerMember
 
         private void ValidateResult(Double[] left, Double[] right, Double[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (BitConverter.DoubleToInt64Bits(result[0]) != BitConverter.DoubleToInt64Bits(Math.Ceiling(right[0])))
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -384,19 +391,21 @@ private void ValidateResult(Double[] left, Double[] right, Double[] result, [Cal
                 {
                     if (BitConverter.DoubleToInt64Bits(result[i]) != BitConverter.DoubleToInt64Bits(left[i]))
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Sse41)}.{nameof(Sse41.CeilingScalar)}<Double>(Vector128<Double>, Vector128<Double>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/CeilingScalar.Single.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/CeilingScalar.Single.cs
index 5677da3a3d77..2b13694b5d2d 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/CeilingScalar.Single.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/CeilingScalar.Single.cs
@@ -334,7 +334,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -342,7 +342,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -374,9 +379,11 @@ private void ValidateResult(void* left, void* right, void* result, [CallerMember
 
         private void ValidateResult(Single[] left, Single[] right, Single[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (BitConverter.SingleToInt32Bits(result[0]) != BitConverter.SingleToInt32Bits(MathF.Ceiling(right[0])))
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -384,19 +391,21 @@ private void ValidateResult(Single[] left, Single[] right, Single[] result, [Cal
                 {
                     if (BitConverter.SingleToInt32Bits(result[i]) != BitConverter.SingleToInt32Bits(left[i]))
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Sse41)}.{nameof(Sse41.CeilingScalar)}<Single>(Vector128<Single>, Vector128<Single>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/CompareEqual.Int64.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/CompareEqual.Int64.cs
index 05998d2e6a17..65a7131c9d49 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/CompareEqual.Int64.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/CompareEqual.Int64.cs
@@ -334,7 +334,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -342,7 +342,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -374,9 +379,11 @@ private void ValidateResult(void* left, void* right, void* result, [CallerMember
 
         private void ValidateResult(Int64[] left, Int64[] right, Int64[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (result[0] != ((left[0] == right[0]) ? unchecked((long)(-1)) : 0))
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -384,19 +391,21 @@ private void ValidateResult(Int64[] left, Int64[] right, Int64[] result, [Caller
                 {
                     if (result[i] != ((left[i] == right[i]) ? unchecked((long)(-1)) : 0))
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Sse41)}.{nameof(Sse41.CompareEqual)}<Int64>(Vector128<Int64>, Vector128<Int64>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/CompareEqual.UInt64.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/CompareEqual.UInt64.cs
index 02259e154e5b..9ac1a88275eb 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/CompareEqual.UInt64.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/CompareEqual.UInt64.cs
@@ -334,7 +334,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -342,7 +342,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -374,9 +379,11 @@ private void ValidateResult(void* left, void* right, void* result, [CallerMember
 
         private void ValidateResult(UInt64[] left, UInt64[] right, UInt64[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (result[0] != ((left[0] == right[0]) ? unchecked((ulong)(-1)) : 0))
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -384,19 +391,21 @@ private void ValidateResult(UInt64[] left, UInt64[] right, UInt64[] result, [Cal
                 {
                     if (result[i] != ((left[i] == right[i]) ? unchecked((ulong)(-1)) : 0))
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Sse41)}.{nameof(Sse41.CompareEqual)}<UInt64>(Vector128<UInt64>, Vector128<UInt64>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/Extract.Byte.1.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/Extract.Byte.1.cs
index 45012f8ba9da..86074c7129ca 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/Extract.Byte.1.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/Extract.Byte.1.cs
@@ -319,7 +319,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -327,7 +327,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -355,17 +360,21 @@ private void ValidateResult(void* firstOp, void* result, [CallerMemberName] stri
 
         private void ValidateResult(Byte[] firstOp, Byte[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if ((result[0] != firstOp[1]))
             {
-                Succeeded = false;
+                succeeded = false;
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Sse41)}.{nameof(Sse41.Extract)}<Byte>(Vector128<Byte><9>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"  firstOp: ({string.Join(", ", firstOp)})");
                 TestLibrary.TestFramework.LogInformation($"   result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/Extract.Byte.129.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/Extract.Byte.129.cs
index ae32f5c08b77..667b427c82c6 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/Extract.Byte.129.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/Extract.Byte.129.cs
@@ -319,7 +319,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -327,7 +327,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -355,17 +360,21 @@ private void ValidateResult(void* firstOp, void* result, [CallerMemberName] stri
 
         private void ValidateResult(Byte[] firstOp, Byte[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if ((result[0] != firstOp[1]))
             {
-                Succeeded = false;
+                succeeded = false;
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Sse41)}.{nameof(Sse41.Extract)}<Byte>(Vector128<Byte><9>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"  firstOp: ({string.Join(", ", firstOp)})");
                 TestLibrary.TestFramework.LogInformation($"   result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/Extract.Int32.1.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/Extract.Int32.1.cs
index 7e59d0e6faed..982d05758772 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/Extract.Int32.1.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/Extract.Int32.1.cs
@@ -319,7 +319,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -327,7 +327,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -355,17 +360,21 @@ private void ValidateResult(void* firstOp, void* result, [CallerMemberName] stri
 
         private void ValidateResult(Int32[] firstOp, Int32[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if ((result[0] != firstOp[1]))
             {
-                Succeeded = false;
+                succeeded = false;
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Sse41)}.{nameof(Sse41.Extract)}<Int32>(Vector128<Int32><9>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"  firstOp: ({string.Join(", ", firstOp)})");
                 TestLibrary.TestFramework.LogInformation($"   result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/Extract.Int32.129.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/Extract.Int32.129.cs
index 92b4fc6000b4..0f25815a09bc 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/Extract.Int32.129.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/Extract.Int32.129.cs
@@ -319,7 +319,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -327,7 +327,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -355,17 +360,21 @@ private void ValidateResult(void* firstOp, void* result, [CallerMemberName] stri
 
         private void ValidateResult(Int32[] firstOp, Int32[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if ((result[0] != firstOp[1]))
             {
-                Succeeded = false;
+                succeeded = false;
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Sse41)}.{nameof(Sse41.Extract)}<Int32>(Vector128<Int32><9>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"  firstOp: ({string.Join(", ", firstOp)})");
                 TestLibrary.TestFramework.LogInformation($"   result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/Extract.Int64.1.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/Extract.Int64.1.cs
index 903598d58c57..7048af49401a 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/Extract.Int64.1.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/Extract.Int64.1.cs
@@ -319,7 +319,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -327,7 +327,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -355,17 +360,21 @@ private void ValidateResult(void* firstOp, void* result, [CallerMemberName] stri
 
         private void ValidateResult(Int64[] firstOp, Int64[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if ((result[0] != firstOp[1]))
             {
-                Succeeded = false;
+                succeeded = false;
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Sse41)}.{nameof(Sse41.Extract)}<Int64>(Vector128<Int64><9>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"  firstOp: ({string.Join(", ", firstOp)})");
                 TestLibrary.TestFramework.LogInformation($"   result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/Extract.Int64.129.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/Extract.Int64.129.cs
index 12685b1b1dff..bdbeee6326c0 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/Extract.Int64.129.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/Extract.Int64.129.cs
@@ -319,7 +319,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -327,7 +327,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -355,17 +360,21 @@ private void ValidateResult(void* firstOp, void* result, [CallerMemberName] stri
 
         private void ValidateResult(Int64[] firstOp, Int64[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if ((result[0] != firstOp[1]))
             {
-                Succeeded = false;
+                succeeded = false;
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Sse41)}.{nameof(Sse41.Extract)}<Int64>(Vector128<Int64><9>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"  firstOp: ({string.Join(", ", firstOp)})");
                 TestLibrary.TestFramework.LogInformation($"   result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/Extract.Single.1.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/Extract.Single.1.cs
index 0fa3b98455ac..7227996011c4 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/Extract.Single.1.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/Extract.Single.1.cs
@@ -319,7 +319,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -327,7 +327,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -355,17 +360,21 @@ private void ValidateResult(void* firstOp, void* result, [CallerMemberName] stri
 
         private void ValidateResult(Single[] firstOp, Single[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if ((BitConverter.SingleToInt32Bits(result[0]) != BitConverter.SingleToInt32Bits(firstOp[1])))
             {
-                Succeeded = false;
+                succeeded = false;
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Sse41)}.{nameof(Sse41.Extract)}<Single>(Vector128<Single><9>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"  firstOp: ({string.Join(", ", firstOp)})");
                 TestLibrary.TestFramework.LogInformation($"   result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/Extract.Single.129.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/Extract.Single.129.cs
index a1fc3ac6d986..5ae017581d86 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/Extract.Single.129.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/Extract.Single.129.cs
@@ -319,7 +319,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -327,7 +327,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -355,17 +360,21 @@ private void ValidateResult(void* firstOp, void* result, [CallerMemberName] stri
 
         private void ValidateResult(Single[] firstOp, Single[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if ((BitConverter.SingleToInt32Bits(result[0]) != BitConverter.SingleToInt32Bits(firstOp[1])))
             {
-                Succeeded = false;
+                succeeded = false;
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Sse41)}.{nameof(Sse41.Extract)}<Single>(Vector128<Single><9>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"  firstOp: ({string.Join(", ", firstOp)})");
                 TestLibrary.TestFramework.LogInformation($"   result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/Extract.UInt32.1.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/Extract.UInt32.1.cs
index 65db7dd2cf29..6b7fd39174a9 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/Extract.UInt32.1.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/Extract.UInt32.1.cs
@@ -319,7 +319,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -327,7 +327,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -355,17 +360,21 @@ private void ValidateResult(void* firstOp, void* result, [CallerMemberName] stri
 
         private void ValidateResult(UInt32[] firstOp, UInt32[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if ((result[0] != firstOp[1]))
             {
-                Succeeded = false;
+                succeeded = false;
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Sse41)}.{nameof(Sse41.Extract)}<UInt32>(Vector128<UInt32><9>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"  firstOp: ({string.Join(", ", firstOp)})");
                 TestLibrary.TestFramework.LogInformation($"   result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/Extract.UInt32.129.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/Extract.UInt32.129.cs
index b77c4b2fb957..a601ce2cc33f 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/Extract.UInt32.129.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/Extract.UInt32.129.cs
@@ -319,7 +319,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -327,7 +327,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -355,17 +360,21 @@ private void ValidateResult(void* firstOp, void* result, [CallerMemberName] stri
 
         private void ValidateResult(UInt32[] firstOp, UInt32[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if ((result[0] != firstOp[1]))
             {
-                Succeeded = false;
+                succeeded = false;
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Sse41)}.{nameof(Sse41.Extract)}<UInt32>(Vector128<UInt32><9>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"  firstOp: ({string.Join(", ", firstOp)})");
                 TestLibrary.TestFramework.LogInformation($"   result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/Extract.UInt64.1.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/Extract.UInt64.1.cs
index 0e3c6f6abd50..39dfa3a925b7 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/Extract.UInt64.1.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/Extract.UInt64.1.cs
@@ -319,7 +319,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -327,7 +327,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -355,17 +360,21 @@ private void ValidateResult(void* firstOp, void* result, [CallerMemberName] stri
 
         private void ValidateResult(UInt64[] firstOp, UInt64[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if ((result[0] != firstOp[1]))
             {
-                Succeeded = false;
+                succeeded = false;
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Sse41)}.{nameof(Sse41.Extract)}<UInt64>(Vector128<UInt64><9>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"  firstOp: ({string.Join(", ", firstOp)})");
                 TestLibrary.TestFramework.LogInformation($"   result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/Extract.UInt64.129.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/Extract.UInt64.129.cs
index 90e414c7f7fd..849de902ea9e 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/Extract.UInt64.129.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/Extract.UInt64.129.cs
@@ -319,7 +319,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -327,7 +327,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -355,17 +360,21 @@ private void ValidateResult(void* firstOp, void* result, [CallerMemberName] stri
 
         private void ValidateResult(UInt64[] firstOp, UInt64[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if ((result[0] != firstOp[1]))
             {
-                Succeeded = false;
+                succeeded = false;
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Sse41)}.{nameof(Sse41.Extract)}<UInt64>(Vector128<UInt64><9>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"  firstOp: ({string.Join(", ", firstOp)})");
                 TestLibrary.TestFramework.LogInformation($"   result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/Floor.Double.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/Floor.Double.cs
index 03800e68ab01..d85d28d78d96 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/Floor.Double.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/Floor.Double.cs
@@ -312,7 +312,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -320,7 +320,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -348,9 +353,11 @@ private void ValidateResult(void* firstOp, void* result, [CallerMemberName] stri
 
         private void ValidateResult(Double[] firstOp, Double[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (BitConverter.DoubleToInt64Bits(result[0]) != BitConverter.DoubleToInt64Bits(Math.Floor(firstOp[0])))
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -358,18 +365,20 @@ private void ValidateResult(Double[] firstOp, Double[] result, [CallerMemberName
                 {
                     if (BitConverter.DoubleToInt64Bits(result[i]) != BitConverter.DoubleToInt64Bits(Math.Floor(firstOp[i])))
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Sse41)}.{nameof(Sse41.Floor)}<Double>(Vector128<Double>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"  firstOp: ({string.Join(", ", firstOp)})");
                 TestLibrary.TestFramework.LogInformation($"   result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/Floor.Single.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/Floor.Single.cs
index e9483f3ffd89..595f75e7dcdc 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/Floor.Single.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/Floor.Single.cs
@@ -312,7 +312,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -320,7 +320,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -348,9 +353,11 @@ private void ValidateResult(void* firstOp, void* result, [CallerMemberName] stri
 
         private void ValidateResult(Single[] firstOp, Single[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (BitConverter.SingleToInt32Bits(result[0]) != BitConverter.SingleToInt32Bits(MathF.Floor(firstOp[0])))
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -358,18 +365,20 @@ private void ValidateResult(Single[] firstOp, Single[] result, [CallerMemberName
                 {
                     if (BitConverter.SingleToInt32Bits(result[i]) != BitConverter.SingleToInt32Bits(MathF.Floor(firstOp[i])))
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Sse41)}.{nameof(Sse41.Floor)}<Single>(Vector128<Single>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"  firstOp: ({string.Join(", ", firstOp)})");
                 TestLibrary.TestFramework.LogInformation($"   result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/FloorScalar.Double.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/FloorScalar.Double.cs
index 7859b50c708d..74bcbadb7a67 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/FloorScalar.Double.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/FloorScalar.Double.cs
@@ -334,7 +334,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -342,7 +342,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -374,9 +379,11 @@ private void ValidateResult(void* left, void* right, void* result, [CallerMember
 
         private void ValidateResult(Double[] left, Double[] right, Double[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (BitConverter.DoubleToInt64Bits(result[0]) != BitConverter.DoubleToInt64Bits(Math.Floor(right[0])))
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -384,19 +391,21 @@ private void ValidateResult(Double[] left, Double[] right, Double[] result, [Cal
                 {
                     if (BitConverter.DoubleToInt64Bits(result[i]) != BitConverter.DoubleToInt64Bits(left[i]))
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Sse41)}.{nameof(Sse41.FloorScalar)}<Double>(Vector128<Double>, Vector128<Double>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/FloorScalar.Single.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/FloorScalar.Single.cs
index d41aa62c2192..52d55ba01aab 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/FloorScalar.Single.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/FloorScalar.Single.cs
@@ -334,7 +334,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -342,7 +342,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -374,9 +379,11 @@ private void ValidateResult(void* left, void* right, void* result, [CallerMember
 
         private void ValidateResult(Single[] left, Single[] right, Single[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (BitConverter.SingleToInt32Bits(result[0]) != BitConverter.SingleToInt32Bits(MathF.Floor(right[0])))
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -384,19 +391,21 @@ private void ValidateResult(Single[] left, Single[] right, Single[] result, [Cal
                 {
                     if (BitConverter.SingleToInt32Bits(result[i]) != BitConverter.SingleToInt32Bits(left[i]))
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Sse41)}.{nameof(Sse41.FloorScalar)}<Single>(Vector128<Single>, Vector128<Single>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/Insert.Byte.1.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/Insert.Byte.1.cs
index 1087ce7d9787..e4900115055e 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/Insert.Byte.1.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/Insert.Byte.1.cs
@@ -326,7 +326,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -334,7 +334,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -362,22 +367,25 @@ private void ValidateResult(void* firstOp, void* result, [CallerMemberName] stri
 
         private void ValidateResult(Byte[] firstOp, Byte[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
 
             for (var i = 0; i < RetElementCount; i++)
             {
                 if ((i == 1 ? result[i] != 2 : result[i] != firstOp[i]))
                 {
-                    Succeeded = false;
+                    succeeded = false;
                     break;
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Sse41)}.{nameof(Sse41.Insert)}<Byte>(Vector128<Byte><9>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"  firstOp: ({string.Join(", ", firstOp)})");
                 TestLibrary.TestFramework.LogInformation($"   result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/Insert.Byte.129.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/Insert.Byte.129.cs
index 5335b1ac5a61..fc2a96bc30b0 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/Insert.Byte.129.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/Insert.Byte.129.cs
@@ -326,7 +326,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -334,7 +334,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -362,22 +367,25 @@ private void ValidateResult(void* firstOp, void* result, [CallerMemberName] stri
 
         private void ValidateResult(Byte[] firstOp, Byte[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
 
             for (var i = 0; i < RetElementCount; i++)
             {
                 if ((i == 1 ? result[i] != 2 : result[i] != firstOp[i]))
                 {
-                    Succeeded = false;
+                    succeeded = false;
                     break;
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Sse41)}.{nameof(Sse41.Insert)}<Byte>(Vector128<Byte><9>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"  firstOp: ({string.Join(", ", firstOp)})");
                 TestLibrary.TestFramework.LogInformation($"   result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/Insert.Int32.1.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/Insert.Int32.1.cs
index e4d82ca53102..e01714ae8e25 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/Insert.Int32.1.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/Insert.Int32.1.cs
@@ -326,7 +326,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -334,7 +334,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -362,22 +367,25 @@ private void ValidateResult(void* firstOp, void* result, [CallerMemberName] stri
 
         private void ValidateResult(Int32[] firstOp, Int32[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
 
             for (var i = 0; i < RetElementCount; i++)
             {
                 if ((i == 1 ? result[i] != 2 : result[i] != firstOp[i]))
                 {
-                    Succeeded = false;
+                    succeeded = false;
                     break;
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Sse41)}.{nameof(Sse41.Insert)}<Int32>(Vector128<Int32><9>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"  firstOp: ({string.Join(", ", firstOp)})");
                 TestLibrary.TestFramework.LogInformation($"   result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/Insert.Int32.129.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/Insert.Int32.129.cs
index 6d27eb8a4628..71d9c725f8c2 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/Insert.Int32.129.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/Insert.Int32.129.cs
@@ -326,7 +326,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -334,7 +334,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -362,22 +367,25 @@ private void ValidateResult(void* firstOp, void* result, [CallerMemberName] stri
 
         private void ValidateResult(Int32[] firstOp, Int32[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
 
             for (var i = 0; i < RetElementCount; i++)
             {
                 if ((i == 1 ? result[i] != 2 : result[i] != firstOp[i]))
                 {
-                    Succeeded = false;
+                    succeeded = false;
                     break;
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Sse41)}.{nameof(Sse41.Insert)}<Int32>(Vector128<Int32><9>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"  firstOp: ({string.Join(", ", firstOp)})");
                 TestLibrary.TestFramework.LogInformation($"   result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/Insert.Int64.1.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/Insert.Int64.1.cs
index cb25791cf340..e3c2d3ecefdf 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/Insert.Int64.1.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/Insert.Int64.1.cs
@@ -326,7 +326,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -334,7 +334,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -362,22 +367,25 @@ private void ValidateResult(void* firstOp, void* result, [CallerMemberName] stri
 
         private void ValidateResult(Int64[] firstOp, Int64[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
 
             for (var i = 0; i < RetElementCount; i++)
             {
                 if ((i == 1 ? result[i] != 2 : result[i] != firstOp[i]))
                 {
-                    Succeeded = false;
+                    succeeded = false;
                     break;
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Sse41)}.{nameof(Sse41.Insert)}<Int64>(Vector128<Int64><9>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"  firstOp: ({string.Join(", ", firstOp)})");
                 TestLibrary.TestFramework.LogInformation($"   result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/Insert.Int64.129.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/Insert.Int64.129.cs
index 4a33dcd8c78a..8e1c39ad1a64 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/Insert.Int64.129.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/Insert.Int64.129.cs
@@ -326,7 +326,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -334,7 +334,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -362,22 +367,25 @@ private void ValidateResult(void* firstOp, void* result, [CallerMemberName] stri
 
         private void ValidateResult(Int64[] firstOp, Int64[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
 
             for (var i = 0; i < RetElementCount; i++)
             {
                 if ((i == 1 ? result[i] != 2 : result[i] != firstOp[i]))
                 {
-                    Succeeded = false;
+                    succeeded = false;
                     break;
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Sse41)}.{nameof(Sse41.Insert)}<Int64>(Vector128<Int64><9>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"  firstOp: ({string.Join(", ", firstOp)})");
                 TestLibrary.TestFramework.LogInformation($"   result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/Insert.SByte.1.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/Insert.SByte.1.cs
index be32281e14c1..0f4955875700 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/Insert.SByte.1.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/Insert.SByte.1.cs
@@ -326,7 +326,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -334,7 +334,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -362,22 +367,25 @@ private void ValidateResult(void* firstOp, void* result, [CallerMemberName] stri
 
         private void ValidateResult(SByte[] firstOp, SByte[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
 
             for (var i = 0; i < RetElementCount; i++)
             {
                 if ((i == 1 ? result[i] != 2 : result[i] != firstOp[i]))
                 {
-                    Succeeded = false;
+                    succeeded = false;
                     break;
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Sse41)}.{nameof(Sse41.Insert)}<SByte>(Vector128<SByte><9>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"  firstOp: ({string.Join(", ", firstOp)})");
                 TestLibrary.TestFramework.LogInformation($"   result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/Insert.SByte.129.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/Insert.SByte.129.cs
index 1cf7e01015a7..2b8595890bbe 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/Insert.SByte.129.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/Insert.SByte.129.cs
@@ -326,7 +326,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -334,7 +334,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -362,22 +367,25 @@ private void ValidateResult(void* firstOp, void* result, [CallerMemberName] stri
 
         private void ValidateResult(SByte[] firstOp, SByte[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
 
             for (var i = 0; i < RetElementCount; i++)
             {
                 if ((i == 1 ? result[i] != 2 : result[i] != firstOp[i]))
                 {
-                    Succeeded = false;
+                    succeeded = false;
                     break;
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Sse41)}.{nameof(Sse41.Insert)}<SByte>(Vector128<SByte><9>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"  firstOp: ({string.Join(", ", firstOp)})");
                 TestLibrary.TestFramework.LogInformation($"   result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/Insert.Single.0.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/Insert.Single.0.cs
index a46bf18f5f50..ae54cc862a70 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/Insert.Single.0.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/Insert.Single.0.cs
@@ -343,7 +343,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -351,7 +351,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -383,9 +388,11 @@ private void ValidateResult(void* left, void* right, void* result, [CallerMember
 
         private void ValidateResult(Single[] left, Single[] right, Single[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (BitConverter.SingleToInt32Bits(result[0]) != BitConverter.SingleToInt32Bits(right[0]))
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -393,19 +400,21 @@ private void ValidateResult(Single[] left, Single[] right, Single[] result, [Cal
                 {
                     if (BitConverter.SingleToInt32Bits(result[i]) != BitConverter.SingleToInt32Bits(left[i]))
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Sse41)}.{nameof(Sse41.Insert)}<Single>(Vector128<Single>, Vector128<Single>.0): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/Insert.Single.1.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/Insert.Single.1.cs
index b8a9206b0eaa..ec70a101794a 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/Insert.Single.1.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/Insert.Single.1.cs
@@ -343,7 +343,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -351,7 +351,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -383,9 +388,11 @@ private void ValidateResult(void* left, void* right, void* result, [CallerMember
 
         private void ValidateResult(Single[] left, Single[] right, Single[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (BitConverter.SingleToInt32Bits(result[0]) != BitConverter.SingleToInt32Bits(0.0f))
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -393,19 +400,21 @@ private void ValidateResult(Single[] left, Single[] right, Single[] result, [Cal
                 {
                     if (BitConverter.SingleToInt32Bits(result[i]) != BitConverter.SingleToInt32Bits(left[i]))
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Sse41)}.{nameof(Sse41.Insert)}<Single>(Vector128<Single>, Vector128<Single>.1): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/Insert.Single.128.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/Insert.Single.128.cs
index a364316ce4fd..85752641a970 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/Insert.Single.128.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/Insert.Single.128.cs
@@ -343,7 +343,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -351,7 +351,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -383,9 +388,11 @@ private void ValidateResult(void* left, void* right, void* result, [CallerMember
 
         private void ValidateResult(Single[] left, Single[] right, Single[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (BitConverter.SingleToInt32Bits(result[0]) != BitConverter.SingleToInt32Bits(right[2]))
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -393,19 +400,21 @@ private void ValidateResult(Single[] left, Single[] right, Single[] result, [Cal
                 {
                     if (BitConverter.SingleToInt32Bits(result[i]) != BitConverter.SingleToInt32Bits(left[i]))
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Sse41)}.{nameof(Sse41.Insert)}<Single>(Vector128<Single>, Vector128<Single>.128): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/Insert.Single.129.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/Insert.Single.129.cs
index 79ce9a060a96..9c638f48fd4c 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/Insert.Single.129.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/Insert.Single.129.cs
@@ -343,7 +343,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -351,7 +351,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -383,9 +388,11 @@ private void ValidateResult(void* left, void* right, void* result, [CallerMember
 
         private void ValidateResult(Single[] left, Single[] right, Single[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (BitConverter.SingleToInt32Bits(result[0]) != BitConverter.SingleToInt32Bits(0.0f))
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -393,19 +400,21 @@ private void ValidateResult(Single[] left, Single[] right, Single[] result, [Cal
                 {
                     if (BitConverter.SingleToInt32Bits(result[i]) != BitConverter.SingleToInt32Bits(left[i]))
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Sse41)}.{nameof(Sse41.Insert)}<Single>(Vector128<Single>, Vector128<Single>.129): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/Insert.Single.16.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/Insert.Single.16.cs
index bd089e027c1a..4fa476981fda 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/Insert.Single.16.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/Insert.Single.16.cs
@@ -343,7 +343,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -351,7 +351,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -383,9 +388,11 @@ private void ValidateResult(void* left, void* right, void* result, [CallerMember
 
         private void ValidateResult(Single[] left, Single[] right, Single[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (BitConverter.SingleToInt32Bits(result[0]) != BitConverter.SingleToInt32Bits(left[0]))
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -393,19 +400,21 @@ private void ValidateResult(Single[] left, Single[] right, Single[] result, [Cal
                 {
                     if (i == 1 ? BitConverter.SingleToInt32Bits(result[i]) != BitConverter.SingleToInt32Bits(right[0]) : BitConverter.SingleToInt32Bits(result[i]) != BitConverter.SingleToInt32Bits(left[i]))
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Sse41)}.{nameof(Sse41.Insert)}<Single>(Vector128<Single>, Vector128<Single>.16): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/Insert.Single.192.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/Insert.Single.192.cs
index ea9988b00565..efe67c5bf7bb 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/Insert.Single.192.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/Insert.Single.192.cs
@@ -343,7 +343,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -351,7 +351,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -383,9 +388,11 @@ private void ValidateResult(void* left, void* right, void* result, [CallerMember
 
         private void ValidateResult(Single[] left, Single[] right, Single[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (BitConverter.SingleToInt32Bits(result[0]) != BitConverter.SingleToInt32Bits(right[3]))
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -393,19 +400,21 @@ private void ValidateResult(Single[] left, Single[] right, Single[] result, [Cal
                 {
                     if (BitConverter.SingleToInt32Bits(result[i]) != BitConverter.SingleToInt32Bits(left[i]))
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Sse41)}.{nameof(Sse41.Insert)}<Single>(Vector128<Single>, Vector128<Single>.192): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/Insert.Single.2.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/Insert.Single.2.cs
index 8c4bc8c7822e..cb4d0311d72d 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/Insert.Single.2.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/Insert.Single.2.cs
@@ -343,7 +343,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -351,7 +351,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -383,9 +388,11 @@ private void ValidateResult(void* left, void* right, void* result, [CallerMember
 
         private void ValidateResult(Single[] left, Single[] right, Single[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (BitConverter.SingleToInt32Bits(result[0]) != BitConverter.SingleToInt32Bits(right[0]))
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -393,19 +400,21 @@ private void ValidateResult(Single[] left, Single[] right, Single[] result, [Cal
                 {
                     if (i == 1 ? BitConverter.SingleToInt32Bits(result[i]) != BitConverter.SingleToInt32Bits(0.0f) : BitConverter.SingleToInt32Bits(result[i]) != BitConverter.SingleToInt32Bits(left[i]))
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Sse41)}.{nameof(Sse41.Insert)}<Single>(Vector128<Single>, Vector128<Single>.2): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/Insert.Single.32.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/Insert.Single.32.cs
index d76b95068692..2cae2b27b779 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/Insert.Single.32.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/Insert.Single.32.cs
@@ -343,7 +343,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -351,7 +351,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -383,9 +388,11 @@ private void ValidateResult(void* left, void* right, void* result, [CallerMember
 
         private void ValidateResult(Single[] left, Single[] right, Single[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (BitConverter.SingleToInt32Bits(result[0]) != BitConverter.SingleToInt32Bits(left[0]))
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -393,19 +400,21 @@ private void ValidateResult(Single[] left, Single[] right, Single[] result, [Cal
                 {
                     if (i == 2 ? BitConverter.SingleToInt32Bits(result[i]) != BitConverter.SingleToInt32Bits(right[0]) : BitConverter.SingleToInt32Bits(result[i]) != BitConverter.SingleToInt32Bits(left[i]))
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Sse41)}.{nameof(Sse41.Insert)}<Single>(Vector128<Single>, Vector128<Single>.32): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/Insert.Single.4.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/Insert.Single.4.cs
index 6b96fb0a5a94..d831611c0d90 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/Insert.Single.4.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/Insert.Single.4.cs
@@ -343,7 +343,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -351,7 +351,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -383,9 +388,11 @@ private void ValidateResult(void* left, void* right, void* result, [CallerMember
 
         private void ValidateResult(Single[] left, Single[] right, Single[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (BitConverter.SingleToInt32Bits(result[0]) != BitConverter.SingleToInt32Bits(right[0]))
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -393,19 +400,21 @@ private void ValidateResult(Single[] left, Single[] right, Single[] result, [Cal
                 {
                     if (i == 2 ? BitConverter.SingleToInt32Bits(result[i]) != BitConverter.SingleToInt32Bits(0.0f) : BitConverter.SingleToInt32Bits(result[i]) != BitConverter.SingleToInt32Bits(left[i]))
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Sse41)}.{nameof(Sse41.Insert)}<Single>(Vector128<Single>, Vector128<Single>.4): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/Insert.Single.48.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/Insert.Single.48.cs
index cd68b174a713..8fe182fc0713 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/Insert.Single.48.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/Insert.Single.48.cs
@@ -343,7 +343,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -351,7 +351,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -383,9 +388,11 @@ private void ValidateResult(void* left, void* right, void* result, [CallerMember
 
         private void ValidateResult(Single[] left, Single[] right, Single[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (BitConverter.SingleToInt32Bits(result[0]) != BitConverter.SingleToInt32Bits(left[0]))
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -393,19 +400,21 @@ private void ValidateResult(Single[] left, Single[] right, Single[] result, [Cal
                 {
                     if (i == 3 ? BitConverter.SingleToInt32Bits(result[i]) != BitConverter.SingleToInt32Bits(right[0]) : BitConverter.SingleToInt32Bits(result[i]) != BitConverter.SingleToInt32Bits(left[i]))
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Sse41)}.{nameof(Sse41.Insert)}<Single>(Vector128<Single>, Vector128<Single>.48): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/Insert.Single.64.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/Insert.Single.64.cs
index 382a18a477b1..89da763e7346 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/Insert.Single.64.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/Insert.Single.64.cs
@@ -343,7 +343,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -351,7 +351,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -383,9 +388,11 @@ private void ValidateResult(void* left, void* right, void* result, [CallerMember
 
         private void ValidateResult(Single[] left, Single[] right, Single[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (BitConverter.SingleToInt32Bits(result[0]) != BitConverter.SingleToInt32Bits(right[1]))
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -393,19 +400,21 @@ private void ValidateResult(Single[] left, Single[] right, Single[] result, [Cal
                 {
                     if (BitConverter.SingleToInt32Bits(result[i]) != BitConverter.SingleToInt32Bits(left[i]))
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Sse41)}.{nameof(Sse41.Insert)}<Single>(Vector128<Single>, Vector128<Single>.64): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/Insert.Single.8.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/Insert.Single.8.cs
index 30537728257a..16f2e166b243 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/Insert.Single.8.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/Insert.Single.8.cs
@@ -343,7 +343,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -351,7 +351,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -383,9 +388,11 @@ private void ValidateResult(void* left, void* right, void* result, [CallerMember
 
         private void ValidateResult(Single[] left, Single[] right, Single[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (BitConverter.SingleToInt32Bits(result[0]) != BitConverter.SingleToInt32Bits(right[0]))
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -393,19 +400,21 @@ private void ValidateResult(Single[] left, Single[] right, Single[] result, [Cal
                 {
                     if (i == 3 ? BitConverter.SingleToInt32Bits(result[i]) != BitConverter.SingleToInt32Bits(0.0f) : BitConverter.SingleToInt32Bits(result[i]) != BitConverter.SingleToInt32Bits(left[i]))
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Sse41)}.{nameof(Sse41.Insert)}<Single>(Vector128<Single>, Vector128<Single>.8): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/Insert.UInt32.1.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/Insert.UInt32.1.cs
index ded030b1fdc7..7d838d5a3b2d 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/Insert.UInt32.1.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/Insert.UInt32.1.cs
@@ -326,7 +326,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -334,7 +334,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -362,22 +367,25 @@ private void ValidateResult(void* firstOp, void* result, [CallerMemberName] stri
 
         private void ValidateResult(UInt32[] firstOp, UInt32[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
 
             for (var i = 0; i < RetElementCount; i++)
             {
                 if ((i == 1 ? result[i] != 2 : result[i] != firstOp[i]))
                 {
-                    Succeeded = false;
+                    succeeded = false;
                     break;
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Sse41)}.{nameof(Sse41.Insert)}<UInt32>(Vector128<UInt32><9>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"  firstOp: ({string.Join(", ", firstOp)})");
                 TestLibrary.TestFramework.LogInformation($"   result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/Insert.UInt32.129.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/Insert.UInt32.129.cs
index a68b779db9e7..23bd5afeec55 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/Insert.UInt32.129.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/Insert.UInt32.129.cs
@@ -326,7 +326,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -334,7 +334,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -362,22 +367,25 @@ private void ValidateResult(void* firstOp, void* result, [CallerMemberName] stri
 
         private void ValidateResult(UInt32[] firstOp, UInt32[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
 
             for (var i = 0; i < RetElementCount; i++)
             {
                 if ((i == 1 ? result[i] != 2 : result[i] != firstOp[i]))
                 {
-                    Succeeded = false;
+                    succeeded = false;
                     break;
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Sse41)}.{nameof(Sse41.Insert)}<UInt32>(Vector128<UInt32><9>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"  firstOp: ({string.Join(", ", firstOp)})");
                 TestLibrary.TestFramework.LogInformation($"   result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/Insert.UInt64.1.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/Insert.UInt64.1.cs
index dab352f515cf..7e7c21a4400a 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/Insert.UInt64.1.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/Insert.UInt64.1.cs
@@ -326,7 +326,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -334,7 +334,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -362,22 +367,25 @@ private void ValidateResult(void* firstOp, void* result, [CallerMemberName] stri
 
         private void ValidateResult(UInt64[] firstOp, UInt64[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
 
             for (var i = 0; i < RetElementCount; i++)
             {
                 if ((i == 1 ? result[i] != 2 : result[i] != firstOp[i]))
                 {
-                    Succeeded = false;
+                    succeeded = false;
                     break;
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Sse41)}.{nameof(Sse41.Insert)}<UInt64>(Vector128<UInt64><9>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"  firstOp: ({string.Join(", ", firstOp)})");
                 TestLibrary.TestFramework.LogInformation($"   result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/Insert.UInt64.129.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/Insert.UInt64.129.cs
index cedeaa7fa6a3..77acb817ea2c 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/Insert.UInt64.129.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/Insert.UInt64.129.cs
@@ -326,7 +326,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -334,7 +334,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -362,22 +367,25 @@ private void ValidateResult(void* firstOp, void* result, [CallerMemberName] stri
 
         private void ValidateResult(UInt64[] firstOp, UInt64[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
 
             for (var i = 0; i < RetElementCount; i++)
             {
                 if ((i == 1 ? result[i] != 2 : result[i] != firstOp[i]))
                 {
-                    Succeeded = false;
+                    succeeded = false;
                     break;
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Sse41)}.{nameof(Sse41.Insert)}<UInt64>(Vector128<UInt64><9>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"  firstOp: ({string.Join(", ", firstOp)})");
                 TestLibrary.TestFramework.LogInformation($"   result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/Max.Int32.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/Max.Int32.cs
index fc0a6d521332..509ed2286345 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/Max.Int32.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/Max.Int32.cs
@@ -334,7 +334,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -342,7 +342,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -374,9 +379,11 @@ private void ValidateResult(void* left, void* right, void* result, [CallerMember
 
         private void ValidateResult(Int32[] left, Int32[] right, Int32[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (result[0] != Math.Max(left[0], right[0]))
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -384,19 +391,21 @@ private void ValidateResult(Int32[] left, Int32[] right, Int32[] result, [Caller
                 {
                     if (result[i] != Math.Max(left[i], right[i]))
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Sse41)}.{nameof(Sse41.Max)}<Int32>(Vector128<Int32>, Vector128<Int32>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/Max.SByte.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/Max.SByte.cs
index e6e2fa0b6a87..504bc711a0c7 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/Max.SByte.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/Max.SByte.cs
@@ -334,7 +334,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -342,7 +342,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -374,9 +379,11 @@ private void ValidateResult(void* left, void* right, void* result, [CallerMember
 
         private void ValidateResult(SByte[] left, SByte[] right, SByte[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (result[0] != Math.Max(left[0], right[0]))
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -384,19 +391,21 @@ private void ValidateResult(SByte[] left, SByte[] right, SByte[] result, [Caller
                 {
                     if (result[i] != Math.Max(left[i], right[i]))
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Sse41)}.{nameof(Sse41.Max)}<SByte>(Vector128<SByte>, Vector128<SByte>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/Max.UInt16.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/Max.UInt16.cs
index 3d53ca2df584..c0f2faf2e87b 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/Max.UInt16.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/Max.UInt16.cs
@@ -334,7 +334,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -342,7 +342,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -374,9 +379,11 @@ private void ValidateResult(void* left, void* right, void* result, [CallerMember
 
         private void ValidateResult(UInt16[] left, UInt16[] right, UInt16[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (result[0] != Math.Max(left[0], right[0]))
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -384,19 +391,21 @@ private void ValidateResult(UInt16[] left, UInt16[] right, UInt16[] result, [Cal
                 {
                     if (result[i] != Math.Max(left[i], right[i]))
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Sse41)}.{nameof(Sse41.Max)}<UInt16>(Vector128<UInt16>, Vector128<UInt16>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/Max.UInt32.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/Max.UInt32.cs
index 0acb5d936452..39df71495042 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/Max.UInt32.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/Max.UInt32.cs
@@ -334,7 +334,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -342,7 +342,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -374,9 +379,11 @@ private void ValidateResult(void* left, void* right, void* result, [CallerMember
 
         private void ValidateResult(UInt32[] left, UInt32[] right, UInt32[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (result[0] != Math.Max(left[0], right[0]))
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -384,19 +391,21 @@ private void ValidateResult(UInt32[] left, UInt32[] right, UInt32[] result, [Cal
                 {
                     if (result[i] != Math.Max(left[i], right[i]))
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Sse41)}.{nameof(Sse41.Max)}<UInt32>(Vector128<UInt32>, Vector128<UInt32>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/Min.Int32.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/Min.Int32.cs
index ee393d9e78a9..42670af84fe2 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/Min.Int32.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/Min.Int32.cs
@@ -334,7 +334,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -342,7 +342,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -374,9 +379,11 @@ private void ValidateResult(void* left, void* right, void* result, [CallerMember
 
         private void ValidateResult(Int32[] left, Int32[] right, Int32[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (result[0] != Math.Min(left[0], right[0]))
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -384,19 +391,21 @@ private void ValidateResult(Int32[] left, Int32[] right, Int32[] result, [Caller
                 {
                     if (result[i] != Math.Min(left[i], right[i]))
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Sse41)}.{nameof(Sse41.Min)}<Int32>(Vector128<Int32>, Vector128<Int32>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/Min.SByte.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/Min.SByte.cs
index cd5a0c46372f..63cf5fccdc2d 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/Min.SByte.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/Min.SByte.cs
@@ -334,7 +334,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -342,7 +342,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -374,9 +379,11 @@ private void ValidateResult(void* left, void* right, void* result, [CallerMember
 
         private void ValidateResult(SByte[] left, SByte[] right, SByte[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (result[0] != Math.Min(left[0], right[0]))
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -384,19 +391,21 @@ private void ValidateResult(SByte[] left, SByte[] right, SByte[] result, [Caller
                 {
                     if (result[i] != Math.Min(left[i], right[i]))
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Sse41)}.{nameof(Sse41.Min)}<SByte>(Vector128<SByte>, Vector128<SByte>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/Min.UInt16.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/Min.UInt16.cs
index 85224f55fb41..8f56c42ea9e3 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/Min.UInt16.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/Min.UInt16.cs
@@ -334,7 +334,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -342,7 +342,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -374,9 +379,11 @@ private void ValidateResult(void* left, void* right, void* result, [CallerMember
 
         private void ValidateResult(UInt16[] left, UInt16[] right, UInt16[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (result[0] != Math.Min(left[0], right[0]))
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -384,19 +391,21 @@ private void ValidateResult(UInt16[] left, UInt16[] right, UInt16[] result, [Cal
                 {
                     if (result[i] != Math.Min(left[i], right[i]))
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Sse41)}.{nameof(Sse41.Min)}<UInt16>(Vector128<UInt16>, Vector128<UInt16>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/Min.UInt32.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/Min.UInt32.cs
index 2af6faf99f8b..acafa90c8e53 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/Min.UInt32.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/Min.UInt32.cs
@@ -334,7 +334,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -342,7 +342,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -374,9 +379,11 @@ private void ValidateResult(void* left, void* right, void* result, [CallerMember
 
         private void ValidateResult(UInt32[] left, UInt32[] right, UInt32[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (result[0] != Math.Min(left[0], right[0]))
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -384,19 +391,21 @@ private void ValidateResult(UInt32[] left, UInt32[] right, UInt32[] result, [Cal
                 {
                     if (result[i] != Math.Min(left[i], right[i]))
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Sse41)}.{nameof(Sse41.Min)}<UInt32>(Vector128<UInt32>, Vector128<UInt32>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/MultiplyLow.Int32.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/MultiplyLow.Int32.cs
index b7cc73c85231..4a32cc1dc70e 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/MultiplyLow.Int32.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/MultiplyLow.Int32.cs
@@ -334,7 +334,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -342,7 +342,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -374,9 +379,11 @@ private void ValidateResult(void* left, void* right, void* result, [CallerMember
 
         private void ValidateResult(Int32[] left, Int32[] right, Int32[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (result[0] != BitConverter.ToInt32(BitConverter.GetBytes(((long)(left[0])) * right[0]), 0))
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -384,19 +391,21 @@ private void ValidateResult(Int32[] left, Int32[] right, Int32[] result, [Caller
                 {
                     if (result[i] != BitConverter.ToInt32(BitConverter.GetBytes(((long)(left[i])) * right[i]), 0))
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Sse41)}.{nameof(Sse41.MultiplyLow)}<Int32>(Vector128<Int32>, Vector128<Int32>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/MultiplyLow.UInt32.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/MultiplyLow.UInt32.cs
index 09ecb527c088..0307d666a0bc 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/MultiplyLow.UInt32.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/MultiplyLow.UInt32.cs
@@ -334,7 +334,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -342,7 +342,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -374,9 +379,11 @@ private void ValidateResult(void* left, void* right, void* result, [CallerMember
 
         private void ValidateResult(UInt32[] left, UInt32[] right, UInt32[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (result[0] != BitConverter.ToUInt32(BitConverter.GetBytes(((ulong)(left[0])) * right[0]), 0))
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -384,19 +391,21 @@ private void ValidateResult(UInt32[] left, UInt32[] right, UInt32[] result, [Cal
                 {
                     if (result[i] != BitConverter.ToUInt32(BitConverter.GetBytes(((ulong)(left[i])) * right[i]), 0))
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Sse41)}.{nameof(Sse41.MultiplyLow)}<UInt32>(Vector128<UInt32>, Vector128<UInt32>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/PackUnsignedSaturate.UInt16.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/PackUnsignedSaturate.UInt16.cs
index 1c11dc9be277..8e0788db487c 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/PackUnsignedSaturate.UInt16.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/PackUnsignedSaturate.UInt16.cs
@@ -334,7 +334,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -342,7 +342,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -374,6 +379,8 @@ private void ValidateResult(void* left, void* right, void* result, [CallerMember
 
         private void ValidateResult(Int32[] left, Int32[] right, UInt16[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             for (var outer = 0; outer < (LargestVectorSize / 16); outer++)
             {
                 for (var inner = 0; inner < (8 / sizeof(UInt16)); inner++)
@@ -384,25 +391,27 @@ private void ValidateResult(Int32[] left, Int32[] right, UInt16[] result, [Calle
 
                     if (result[i1] != ((left[i3 - inner] > 0xFFFF) ? 0xFFFF : ((left[i3 - inner] < 0) ? 0 : BitConverter.ToUInt16(BitConverter.GetBytes(left[i3 - inner]), 0))))
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
 
                     if (result[i2] != ((right[i3 - inner] > 0xFFFF) ? 0xFFFF : ((right[i3 - inner] < 0) ? 0 : BitConverter.ToUInt16(BitConverter.GetBytes(right[i3 - inner]), 0))))
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Sse41)}.{nameof(Sse41.PackUnsignedSaturate)}<UInt16>(Vector128<Int32>, Vector128<Int32>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/RoundCurrentDirection.Double.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/RoundCurrentDirection.Double.cs
index a0e3717ae7e3..501ee8ebb613 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/RoundCurrentDirection.Double.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/RoundCurrentDirection.Double.cs
@@ -312,7 +312,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -320,7 +320,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -348,9 +353,11 @@ private void ValidateResult(void* firstOp, void* result, [CallerMemberName] stri
 
         private void ValidateResult(Double[] firstOp, Double[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (BitConverter.DoubleToInt64Bits(result[0]) != BitConverter.DoubleToInt64Bits(Math.Round(firstOp[0])))
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -358,18 +365,20 @@ private void ValidateResult(Double[] firstOp, Double[] result, [CallerMemberName
                 {
                     if (BitConverter.DoubleToInt64Bits(result[i]) != BitConverter.DoubleToInt64Bits(Math.Round(firstOp[i])))
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Sse41)}.{nameof(Sse41.RoundCurrentDirection)}<Double>(Vector128<Double>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"  firstOp: ({string.Join(", ", firstOp)})");
                 TestLibrary.TestFramework.LogInformation($"   result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/RoundCurrentDirection.Single.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/RoundCurrentDirection.Single.cs
index 5f071fa6f229..bad5fb98bd3f 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/RoundCurrentDirection.Single.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/RoundCurrentDirection.Single.cs
@@ -312,7 +312,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -320,7 +320,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -348,9 +353,11 @@ private void ValidateResult(void* firstOp, void* result, [CallerMemberName] stri
 
         private void ValidateResult(Single[] firstOp, Single[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (BitConverter.SingleToInt32Bits(result[0]) != BitConverter.SingleToInt32Bits(MathF.Round(firstOp[0])))
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -358,18 +365,20 @@ private void ValidateResult(Single[] firstOp, Single[] result, [CallerMemberName
                 {
                     if (BitConverter.SingleToInt32Bits(result[i]) != BitConverter.SingleToInt32Bits(MathF.Round(firstOp[i])))
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Sse41)}.{nameof(Sse41.RoundCurrentDirection)}<Single>(Vector128<Single>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"  firstOp: ({string.Join(", ", firstOp)})");
                 TestLibrary.TestFramework.LogInformation($"   result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/RoundCurrentDirectionScalar.Double.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/RoundCurrentDirectionScalar.Double.cs
index 31b41fe56644..98cff1df727b 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/RoundCurrentDirectionScalar.Double.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/RoundCurrentDirectionScalar.Double.cs
@@ -334,7 +334,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -342,7 +342,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -374,9 +379,11 @@ private void ValidateResult(void* left, void* right, void* result, [CallerMember
 
         private void ValidateResult(Double[] left, Double[] right, Double[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (BitConverter.DoubleToInt64Bits(result[0]) != BitConverter.DoubleToInt64Bits(Math.Round(right[0])))
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -384,19 +391,21 @@ private void ValidateResult(Double[] left, Double[] right, Double[] result, [Cal
                 {
                     if (BitConverter.DoubleToInt64Bits(result[i]) != BitConverter.DoubleToInt64Bits(left[i]))
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Sse41)}.{nameof(Sse41.RoundCurrentDirectionScalar)}<Double>(Vector128<Double>, Vector128<Double>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/RoundCurrentDirectionScalar.Single.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/RoundCurrentDirectionScalar.Single.cs
index 3db3c9e02beb..3de43fc18a7a 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/RoundCurrentDirectionScalar.Single.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/RoundCurrentDirectionScalar.Single.cs
@@ -334,7 +334,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -342,7 +342,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -374,9 +379,11 @@ private void ValidateResult(void* left, void* right, void* result, [CallerMember
 
         private void ValidateResult(Single[] left, Single[] right, Single[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (BitConverter.SingleToInt32Bits(result[0]) != BitConverter.SingleToInt32Bits(MathF.Round(right[0])))
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -384,19 +391,21 @@ private void ValidateResult(Single[] left, Single[] right, Single[] result, [Cal
                 {
                     if (BitConverter.SingleToInt32Bits(result[i]) != BitConverter.SingleToInt32Bits(left[i]))
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Sse41)}.{nameof(Sse41.RoundCurrentDirectionScalar)}<Single>(Vector128<Single>, Vector128<Single>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/RoundToNearestInteger.Double.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/RoundToNearestInteger.Double.cs
index 690e9c6bf555..fdd9ed929446 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/RoundToNearestInteger.Double.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/RoundToNearestInteger.Double.cs
@@ -312,7 +312,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -320,7 +320,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -348,9 +353,11 @@ private void ValidateResult(void* firstOp, void* result, [CallerMemberName] stri
 
         private void ValidateResult(Double[] firstOp, Double[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (BitConverter.DoubleToInt64Bits(result[0]) != BitConverter.DoubleToInt64Bits(Math.Round(firstOp[0], MidpointRounding.AwayFromZero)))
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -358,18 +365,20 @@ private void ValidateResult(Double[] firstOp, Double[] result, [CallerMemberName
                 {
                     if (BitConverter.DoubleToInt64Bits(result[i]) != BitConverter.DoubleToInt64Bits(Math.Round(firstOp[i], MidpointRounding.AwayFromZero)))
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Sse41)}.{nameof(Sse41.RoundToNearestInteger)}<Double>(Vector128<Double>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"  firstOp: ({string.Join(", ", firstOp)})");
                 TestLibrary.TestFramework.LogInformation($"   result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/RoundToNearestInteger.Single.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/RoundToNearestInteger.Single.cs
index c6c1d7ae0cb0..21727d334869 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/RoundToNearestInteger.Single.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/RoundToNearestInteger.Single.cs
@@ -312,7 +312,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -320,7 +320,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -348,9 +353,11 @@ private void ValidateResult(void* firstOp, void* result, [CallerMemberName] stri
 
         private void ValidateResult(Single[] firstOp, Single[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (BitConverter.SingleToInt32Bits(result[0]) != BitConverter.SingleToInt32Bits(MathF.Round(firstOp[0], MidpointRounding.AwayFromZero)))
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -358,18 +365,20 @@ private void ValidateResult(Single[] firstOp, Single[] result, [CallerMemberName
                 {
                     if (BitConverter.SingleToInt32Bits(result[i]) != BitConverter.SingleToInt32Bits(MathF.Round(firstOp[i], MidpointRounding.AwayFromZero)))
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Sse41)}.{nameof(Sse41.RoundToNearestInteger)}<Single>(Vector128<Single>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"  firstOp: ({string.Join(", ", firstOp)})");
                 TestLibrary.TestFramework.LogInformation($"   result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/RoundToNearestIntegerScalar.Double.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/RoundToNearestIntegerScalar.Double.cs
index a1fdb6937703..31de8f8696b0 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/RoundToNearestIntegerScalar.Double.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/RoundToNearestIntegerScalar.Double.cs
@@ -334,7 +334,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -342,7 +342,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -374,9 +379,11 @@ private void ValidateResult(void* left, void* right, void* result, [CallerMember
 
         private void ValidateResult(Double[] left, Double[] right, Double[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (BitConverter.DoubleToInt64Bits(result[0]) != BitConverter.DoubleToInt64Bits(Math.Round(right[0], MidpointRounding.AwayFromZero)))
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -384,19 +391,21 @@ private void ValidateResult(Double[] left, Double[] right, Double[] result, [Cal
                 {
                     if (BitConverter.DoubleToInt64Bits(result[i]) != BitConverter.DoubleToInt64Bits(left[i]))
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Sse41)}.{nameof(Sse41.RoundToNearestIntegerScalar)}<Double>(Vector128<Double>, Vector128<Double>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/RoundToNearestIntegerScalar.Single.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/RoundToNearestIntegerScalar.Single.cs
index 6c4ebf6148b1..167f571cee35 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/RoundToNearestIntegerScalar.Single.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/RoundToNearestIntegerScalar.Single.cs
@@ -334,7 +334,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -342,7 +342,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -374,9 +379,11 @@ private void ValidateResult(void* left, void* right, void* result, [CallerMember
 
         private void ValidateResult(Single[] left, Single[] right, Single[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (BitConverter.SingleToInt32Bits(result[0]) != BitConverter.SingleToInt32Bits(MathF.Round(right[0], MidpointRounding.AwayFromZero)))
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -384,19 +391,21 @@ private void ValidateResult(Single[] left, Single[] right, Single[] result, [Cal
                 {
                     if (BitConverter.SingleToInt32Bits(result[i]) != BitConverter.SingleToInt32Bits(left[i]))
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Sse41)}.{nameof(Sse41.RoundToNearestIntegerScalar)}<Single>(Vector128<Single>, Vector128<Single>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/RoundToNegativeInfinity.Double.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/RoundToNegativeInfinity.Double.cs
index 59e4f52647b0..b94b9d1d780a 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/RoundToNegativeInfinity.Double.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/RoundToNegativeInfinity.Double.cs
@@ -312,7 +312,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -320,7 +320,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -348,9 +353,11 @@ private void ValidateResult(void* firstOp, void* result, [CallerMemberName] stri
 
         private void ValidateResult(Double[] firstOp, Double[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (BitConverter.DoubleToInt64Bits(result[0]) != BitConverter.DoubleToInt64Bits(Math.Floor(firstOp[0])))
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -358,18 +365,20 @@ private void ValidateResult(Double[] firstOp, Double[] result, [CallerMemberName
                 {
                     if (BitConverter.DoubleToInt64Bits(result[i]) != BitConverter.DoubleToInt64Bits(Math.Floor(firstOp[i])))
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Sse41)}.{nameof(Sse41.RoundToNegativeInfinity)}<Double>(Vector128<Double>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"  firstOp: ({string.Join(", ", firstOp)})");
                 TestLibrary.TestFramework.LogInformation($"   result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/RoundToNegativeInfinity.Single.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/RoundToNegativeInfinity.Single.cs
index 3916cd1a9892..0a3a98ae4bb1 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/RoundToNegativeInfinity.Single.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/RoundToNegativeInfinity.Single.cs
@@ -312,7 +312,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -320,7 +320,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -348,9 +353,11 @@ private void ValidateResult(void* firstOp, void* result, [CallerMemberName] stri
 
         private void ValidateResult(Single[] firstOp, Single[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (BitConverter.SingleToInt32Bits(result[0]) != BitConverter.SingleToInt32Bits(MathF.Floor(firstOp[0])))
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -358,18 +365,20 @@ private void ValidateResult(Single[] firstOp, Single[] result, [CallerMemberName
                 {
                     if (BitConverter.SingleToInt32Bits(result[i]) != BitConverter.SingleToInt32Bits(MathF.Floor(firstOp[i])))
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Sse41)}.{nameof(Sse41.RoundToNegativeInfinity)}<Single>(Vector128<Single>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"  firstOp: ({string.Join(", ", firstOp)})");
                 TestLibrary.TestFramework.LogInformation($"   result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/RoundToNegativeInfinityScalar.Double.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/RoundToNegativeInfinityScalar.Double.cs
index d0dcef221acd..08d0c9a44335 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/RoundToNegativeInfinityScalar.Double.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/RoundToNegativeInfinityScalar.Double.cs
@@ -334,7 +334,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -342,7 +342,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -374,9 +379,11 @@ private void ValidateResult(void* left, void* right, void* result, [CallerMember
 
         private void ValidateResult(Double[] left, Double[] right, Double[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (BitConverter.DoubleToInt64Bits(result[0]) != BitConverter.DoubleToInt64Bits(Math.Floor(right[0])))
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -384,19 +391,21 @@ private void ValidateResult(Double[] left, Double[] right, Double[] result, [Cal
                 {
                     if (BitConverter.DoubleToInt64Bits(result[i]) != BitConverter.DoubleToInt64Bits(left[i]))
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Sse41)}.{nameof(Sse41.RoundToNegativeInfinityScalar)}<Double>(Vector128<Double>, Vector128<Double>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/RoundToNegativeInfinityScalar.Single.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/RoundToNegativeInfinityScalar.Single.cs
index 59a87518892a..a0fd52d0a477 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/RoundToNegativeInfinityScalar.Single.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/RoundToNegativeInfinityScalar.Single.cs
@@ -334,7 +334,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -342,7 +342,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -374,9 +379,11 @@ private void ValidateResult(void* left, void* right, void* result, [CallerMember
 
         private void ValidateResult(Single[] left, Single[] right, Single[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (BitConverter.SingleToInt32Bits(result[0]) != BitConverter.SingleToInt32Bits(MathF.Floor(right[0])))
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -384,19 +391,21 @@ private void ValidateResult(Single[] left, Single[] right, Single[] result, [Cal
                 {
                     if (BitConverter.SingleToInt32Bits(result[i]) != BitConverter.SingleToInt32Bits(left[i]))
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Sse41)}.{nameof(Sse41.RoundToNegativeInfinityScalar)}<Single>(Vector128<Single>, Vector128<Single>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/RoundToPositiveInfinity.Double.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/RoundToPositiveInfinity.Double.cs
index 99da59e91581..ee11bda9636b 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/RoundToPositiveInfinity.Double.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/RoundToPositiveInfinity.Double.cs
@@ -312,7 +312,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -320,7 +320,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -348,9 +353,11 @@ private void ValidateResult(void* firstOp, void* result, [CallerMemberName] stri
 
         private void ValidateResult(Double[] firstOp, Double[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (BitConverter.DoubleToInt64Bits(result[0]) != BitConverter.DoubleToInt64Bits(Math.Ceiling(firstOp[0])))
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -358,18 +365,20 @@ private void ValidateResult(Double[] firstOp, Double[] result, [CallerMemberName
                 {
                     if (BitConverter.DoubleToInt64Bits(result[i]) != BitConverter.DoubleToInt64Bits(Math.Ceiling(firstOp[i])))
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Sse41)}.{nameof(Sse41.RoundToPositiveInfinity)}<Double>(Vector128<Double>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"  firstOp: ({string.Join(", ", firstOp)})");
                 TestLibrary.TestFramework.LogInformation($"   result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/RoundToPositiveInfinity.Single.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/RoundToPositiveInfinity.Single.cs
index 558caf986bf2..120bccda664b 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/RoundToPositiveInfinity.Single.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/RoundToPositiveInfinity.Single.cs
@@ -312,7 +312,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -320,7 +320,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -348,9 +353,11 @@ private void ValidateResult(void* firstOp, void* result, [CallerMemberName] stri
 
         private void ValidateResult(Single[] firstOp, Single[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (BitConverter.SingleToInt32Bits(result[0]) != BitConverter.SingleToInt32Bits(MathF.Ceiling(firstOp[0])))
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -358,18 +365,20 @@ private void ValidateResult(Single[] firstOp, Single[] result, [CallerMemberName
                 {
                     if (BitConverter.SingleToInt32Bits(result[i]) != BitConverter.SingleToInt32Bits(MathF.Ceiling(firstOp[i])))
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Sse41)}.{nameof(Sse41.RoundToPositiveInfinity)}<Single>(Vector128<Single>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"  firstOp: ({string.Join(", ", firstOp)})");
                 TestLibrary.TestFramework.LogInformation($"   result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/RoundToPositiveInfinityScalar.Double.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/RoundToPositiveInfinityScalar.Double.cs
index af4399669907..749aed6bc7b6 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/RoundToPositiveInfinityScalar.Double.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/RoundToPositiveInfinityScalar.Double.cs
@@ -334,7 +334,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -342,7 +342,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -374,9 +379,11 @@ private void ValidateResult(void* left, void* right, void* result, [CallerMember
 
         private void ValidateResult(Double[] left, Double[] right, Double[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (BitConverter.DoubleToInt64Bits(result[0]) != BitConverter.DoubleToInt64Bits(Math.Ceiling(right[0])))
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -384,19 +391,21 @@ private void ValidateResult(Double[] left, Double[] right, Double[] result, [Cal
                 {
                     if (BitConverter.DoubleToInt64Bits(result[i]) != BitConverter.DoubleToInt64Bits(left[i]))
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Sse41)}.{nameof(Sse41.RoundToPositiveInfinityScalar)}<Double>(Vector128<Double>, Vector128<Double>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/RoundToPositiveInfinityScalar.Single.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/RoundToPositiveInfinityScalar.Single.cs
index 7b733249e588..afe8d99a4009 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/RoundToPositiveInfinityScalar.Single.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/RoundToPositiveInfinityScalar.Single.cs
@@ -334,7 +334,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -342,7 +342,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -374,9 +379,11 @@ private void ValidateResult(void* left, void* right, void* result, [CallerMember
 
         private void ValidateResult(Single[] left, Single[] right, Single[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (BitConverter.SingleToInt32Bits(result[0]) != BitConverter.SingleToInt32Bits(MathF.Ceiling(right[0])))
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -384,19 +391,21 @@ private void ValidateResult(Single[] left, Single[] right, Single[] result, [Cal
                 {
                     if (BitConverter.SingleToInt32Bits(result[i]) != BitConverter.SingleToInt32Bits(left[i]))
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Sse41)}.{nameof(Sse41.RoundToPositiveInfinityScalar)}<Single>(Vector128<Single>, Vector128<Single>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/RoundToZero.Double.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/RoundToZero.Double.cs
index ee8959ec32a1..216a2a276b8f 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/RoundToZero.Double.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/RoundToZero.Double.cs
@@ -312,7 +312,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -320,7 +320,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -348,9 +353,11 @@ private void ValidateResult(void* firstOp, void* result, [CallerMemberName] stri
 
         private void ValidateResult(Double[] firstOp, Double[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (BitConverter.DoubleToInt64Bits(result[0]) != BitConverter.DoubleToInt64Bits((firstOp[0] > 0) ? Math.Floor(firstOp[0]) : Math.Ceiling(firstOp[0])))
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -358,18 +365,20 @@ private void ValidateResult(Double[] firstOp, Double[] result, [CallerMemberName
                 {
                     if (BitConverter.DoubleToInt64Bits(result[i]) != BitConverter.DoubleToInt64Bits((firstOp[i] > 0) ? Math.Floor(firstOp[i]) : Math.Ceiling(firstOp[i])))
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Sse41)}.{nameof(Sse41.RoundToZero)}<Double>(Vector128<Double>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"  firstOp: ({string.Join(", ", firstOp)})");
                 TestLibrary.TestFramework.LogInformation($"   result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/RoundToZero.Single.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/RoundToZero.Single.cs
index 614e10e200db..850c45568fdd 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/RoundToZero.Single.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/RoundToZero.Single.cs
@@ -312,7 +312,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -320,7 +320,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -348,9 +353,11 @@ private void ValidateResult(void* firstOp, void* result, [CallerMemberName] stri
 
         private void ValidateResult(Single[] firstOp, Single[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (BitConverter.SingleToInt32Bits(result[0]) != BitConverter.SingleToInt32Bits((firstOp[0] > 0) ? MathF.Floor(firstOp[0]) : MathF.Ceiling(firstOp[0])))
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -358,18 +365,20 @@ private void ValidateResult(Single[] firstOp, Single[] result, [CallerMemberName
                 {
                     if (BitConverter.SingleToInt32Bits(result[i]) != BitConverter.SingleToInt32Bits((firstOp[i] > 0) ? MathF.Floor(firstOp[i]) : MathF.Ceiling(firstOp[i])))
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Sse41)}.{nameof(Sse41.RoundToZero)}<Single>(Vector128<Single>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"  firstOp: ({string.Join(", ", firstOp)})");
                 TestLibrary.TestFramework.LogInformation($"   result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/RoundToZeroScalar.Double.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/RoundToZeroScalar.Double.cs
index a945959fe82c..59940a374555 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/RoundToZeroScalar.Double.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/RoundToZeroScalar.Double.cs
@@ -334,7 +334,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -342,7 +342,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -374,9 +379,11 @@ private void ValidateResult(void* left, void* right, void* result, [CallerMember
 
         private void ValidateResult(Double[] left, Double[] right, Double[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (BitConverter.DoubleToInt64Bits(result[0]) != BitConverter.DoubleToInt64Bits((right[0] > 0) ? Math.Floor(right[0]) : Math.Ceiling(right[0])))
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -384,19 +391,21 @@ private void ValidateResult(Double[] left, Double[] right, Double[] result, [Cal
                 {
                     if (BitConverter.DoubleToInt64Bits(result[i]) != BitConverter.DoubleToInt64Bits(left[i]))
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Sse41)}.{nameof(Sse41.RoundToZeroScalar)}<Double>(Vector128<Double>, Vector128<Double>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/RoundToZeroScalar.Single.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/RoundToZeroScalar.Single.cs
index 5e0a0547ca61..e3cc5dc6bfa2 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/RoundToZeroScalar.Single.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/RoundToZeroScalar.Single.cs
@@ -334,7 +334,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -342,7 +342,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -374,9 +379,11 @@ private void ValidateResult(void* left, void* right, void* result, [CallerMember
 
         private void ValidateResult(Single[] left, Single[] right, Single[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (BitConverter.SingleToInt32Bits(result[0]) != BitConverter.SingleToInt32Bits((right[0] > 0) ? MathF.Floor(right[0]) : MathF.Ceiling(right[0])))
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -384,19 +391,21 @@ private void ValidateResult(Single[] left, Single[] right, Single[] result, [Cal
                 {
                     if (BitConverter.SingleToInt32Bits(result[i]) != BitConverter.SingleToInt32Bits(left[i]))
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Sse41)}.{nameof(Sse41.RoundToZeroScalar)}<Single>(Vector128<Single>, Vector128<Single>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/TestAllOnes.Byte.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/TestAllOnes.Byte.cs
index 4a7053ed1e84..0ccc97683ee1 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/TestAllOnes.Byte.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/TestAllOnes.Byte.cs
@@ -296,7 +296,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -304,7 +304,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -337,12 +342,12 @@ private void ValidateResult(Byte[] value, bool result, [CallerMemberName] string
 
             if (expectedResult != result)
             {
-                Succeeded = false;
-
                 TestLibrary.TestFramework.LogInformation($"{nameof(Sse41)}.{nameof(Sse41.TestAllOnes)}<Byte>(Vector128<Byte>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    value: ({string.Join(", ", value)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/TestAllOnes.Int16.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/TestAllOnes.Int16.cs
index 8eead89a6ae2..a66141260f22 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/TestAllOnes.Int16.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/TestAllOnes.Int16.cs
@@ -296,7 +296,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -304,7 +304,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -337,12 +342,12 @@ private void ValidateResult(Int16[] value, bool result, [CallerMemberName] strin
 
             if (expectedResult != result)
             {
-                Succeeded = false;
-
                 TestLibrary.TestFramework.LogInformation($"{nameof(Sse41)}.{nameof(Sse41.TestAllOnes)}<Int16>(Vector128<Int16>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    value: ({string.Join(", ", value)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/TestAllOnes.Int32.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/TestAllOnes.Int32.cs
index 899dce665d70..c1f0c8579b74 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/TestAllOnes.Int32.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/TestAllOnes.Int32.cs
@@ -296,7 +296,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -304,7 +304,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -337,12 +342,12 @@ private void ValidateResult(Int32[] value, bool result, [CallerMemberName] strin
 
             if (expectedResult != result)
             {
-                Succeeded = false;
-
                 TestLibrary.TestFramework.LogInformation($"{nameof(Sse41)}.{nameof(Sse41.TestAllOnes)}<Int32>(Vector128<Int32>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    value: ({string.Join(", ", value)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/TestAllOnes.Int64.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/TestAllOnes.Int64.cs
index 8eb6f402a70e..c61795389895 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/TestAllOnes.Int64.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/TestAllOnes.Int64.cs
@@ -296,7 +296,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -304,7 +304,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -337,12 +342,12 @@ private void ValidateResult(Int64[] value, bool result, [CallerMemberName] strin
 
             if (expectedResult != result)
             {
-                Succeeded = false;
-
                 TestLibrary.TestFramework.LogInformation($"{nameof(Sse41)}.{nameof(Sse41.TestAllOnes)}<Int64>(Vector128<Int64>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    value: ({string.Join(", ", value)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/TestAllOnes.SByte.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/TestAllOnes.SByte.cs
index 528459373493..19b3f4318f1b 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/TestAllOnes.SByte.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/TestAllOnes.SByte.cs
@@ -296,7 +296,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -304,7 +304,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -337,12 +342,12 @@ private void ValidateResult(SByte[] value, bool result, [CallerMemberName] strin
 
             if (expectedResult != result)
             {
-                Succeeded = false;
-
                 TestLibrary.TestFramework.LogInformation($"{nameof(Sse41)}.{nameof(Sse41.TestAllOnes)}<SByte>(Vector128<SByte>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    value: ({string.Join(", ", value)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/TestAllOnes.UInt16.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/TestAllOnes.UInt16.cs
index 951731a97b95..6bb530abcbfb 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/TestAllOnes.UInt16.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/TestAllOnes.UInt16.cs
@@ -296,7 +296,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -304,7 +304,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -337,12 +342,12 @@ private void ValidateResult(UInt16[] value, bool result, [CallerMemberName] stri
 
             if (expectedResult != result)
             {
-                Succeeded = false;
-
                 TestLibrary.TestFramework.LogInformation($"{nameof(Sse41)}.{nameof(Sse41.TestAllOnes)}<UInt16>(Vector128<UInt16>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    value: ({string.Join(", ", value)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/TestAllOnes.UInt32.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/TestAllOnes.UInt32.cs
index 4fede7461b24..08b3b8fbe830 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/TestAllOnes.UInt32.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/TestAllOnes.UInt32.cs
@@ -296,7 +296,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -304,7 +304,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -337,12 +342,12 @@ private void ValidateResult(UInt32[] value, bool result, [CallerMemberName] stri
 
             if (expectedResult != result)
             {
-                Succeeded = false;
-
                 TestLibrary.TestFramework.LogInformation($"{nameof(Sse41)}.{nameof(Sse41.TestAllOnes)}<UInt32>(Vector128<UInt32>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    value: ({string.Join(", ", value)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/TestAllOnes.UInt64.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/TestAllOnes.UInt64.cs
index 870b89521876..13c958854148 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/TestAllOnes.UInt64.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/TestAllOnes.UInt64.cs
@@ -296,7 +296,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -304,7 +304,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -337,12 +342,12 @@ private void ValidateResult(UInt64[] value, bool result, [CallerMemberName] stri
 
             if (expectedResult != result)
             {
-                Succeeded = false;
-
                 TestLibrary.TestFramework.LogInformation($"{nameof(Sse41)}.{nameof(Sse41.TestAllOnes)}<UInt64>(Vector128<UInt64>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    value: ({string.Join(", ", value)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/TestAllZeros.Byte.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/TestAllZeros.Byte.cs
index 196a4a8ca345..14e95b2a2809 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/TestAllZeros.Byte.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/TestAllZeros.Byte.cs
@@ -329,7 +329,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -337,7 +337,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -374,13 +379,13 @@ private void ValidateResult(Byte[] left, Byte[] right, bool result, [CallerMembe
 
             if (expectedResult != result)
             {
-                Succeeded = false;
-
                 TestLibrary.TestFramework.LogInformation($"{nameof(Sse41)}.{nameof(Sse41.TestAllZeros)}<Byte>(Vector128<Byte>, Vector128<Byte>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/TestAllZeros.Int16.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/TestAllZeros.Int16.cs
index c7f76179f6d9..1617e451e0e1 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/TestAllZeros.Int16.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/TestAllZeros.Int16.cs
@@ -329,7 +329,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -337,7 +337,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -374,13 +379,13 @@ private void ValidateResult(Int16[] left, Int16[] right, bool result, [CallerMem
 
             if (expectedResult != result)
             {
-                Succeeded = false;
-
                 TestLibrary.TestFramework.LogInformation($"{nameof(Sse41)}.{nameof(Sse41.TestAllZeros)}<Int16>(Vector128<Int16>, Vector128<Int16>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/TestAllZeros.Int32.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/TestAllZeros.Int32.cs
index 6368e0410330..0e88334334cc 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/TestAllZeros.Int32.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/TestAllZeros.Int32.cs
@@ -329,7 +329,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -337,7 +337,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -374,13 +379,13 @@ private void ValidateResult(Int32[] left, Int32[] right, bool result, [CallerMem
 
             if (expectedResult != result)
             {
-                Succeeded = false;
-
                 TestLibrary.TestFramework.LogInformation($"{nameof(Sse41)}.{nameof(Sse41.TestAllZeros)}<Int32>(Vector128<Int32>, Vector128<Int32>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/TestAllZeros.Int64.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/TestAllZeros.Int64.cs
index f273f0f4b26e..fab4dcddf14c 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/TestAllZeros.Int64.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/TestAllZeros.Int64.cs
@@ -329,7 +329,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -337,7 +337,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -374,13 +379,13 @@ private void ValidateResult(Int64[] left, Int64[] right, bool result, [CallerMem
 
             if (expectedResult != result)
             {
-                Succeeded = false;
-
                 TestLibrary.TestFramework.LogInformation($"{nameof(Sse41)}.{nameof(Sse41.TestAllZeros)}<Int64>(Vector128<Int64>, Vector128<Int64>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/TestAllZeros.SByte.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/TestAllZeros.SByte.cs
index ea40e9fa1050..e70a856c42f8 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/TestAllZeros.SByte.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/TestAllZeros.SByte.cs
@@ -329,7 +329,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -337,7 +337,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -374,13 +379,13 @@ private void ValidateResult(SByte[] left, SByte[] right, bool result, [CallerMem
 
             if (expectedResult != result)
             {
-                Succeeded = false;
-
                 TestLibrary.TestFramework.LogInformation($"{nameof(Sse41)}.{nameof(Sse41.TestAllZeros)}<SByte>(Vector128<SByte>, Vector128<SByte>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/TestAllZeros.UInt16.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/TestAllZeros.UInt16.cs
index 3fae2c60de54..30c8b6924f61 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/TestAllZeros.UInt16.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/TestAllZeros.UInt16.cs
@@ -329,7 +329,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -337,7 +337,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -374,13 +379,13 @@ private void ValidateResult(UInt16[] left, UInt16[] right, bool result, [CallerM
 
             if (expectedResult != result)
             {
-                Succeeded = false;
-
                 TestLibrary.TestFramework.LogInformation($"{nameof(Sse41)}.{nameof(Sse41.TestAllZeros)}<UInt16>(Vector128<UInt16>, Vector128<UInt16>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/TestAllZeros.UInt32.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/TestAllZeros.UInt32.cs
index c4a3d98746de..4ea353046481 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/TestAllZeros.UInt32.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/TestAllZeros.UInt32.cs
@@ -329,7 +329,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -337,7 +337,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -374,13 +379,13 @@ private void ValidateResult(UInt32[] left, UInt32[] right, bool result, [CallerM
 
             if (expectedResult != result)
             {
-                Succeeded = false;
-
                 TestLibrary.TestFramework.LogInformation($"{nameof(Sse41)}.{nameof(Sse41.TestAllZeros)}<UInt32>(Vector128<UInt32>, Vector128<UInt32>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/TestAllZeros.UInt64.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/TestAllZeros.UInt64.cs
index ba7d9db36b40..83333a9bafba 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/TestAllZeros.UInt64.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/TestAllZeros.UInt64.cs
@@ -329,7 +329,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -337,7 +337,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -374,13 +379,13 @@ private void ValidateResult(UInt64[] left, UInt64[] right, bool result, [CallerM
 
             if (expectedResult != result)
             {
-                Succeeded = false;
-
                 TestLibrary.TestFramework.LogInformation($"{nameof(Sse41)}.{nameof(Sse41.TestAllZeros)}<UInt64>(Vector128<UInt64>, Vector128<UInt64>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/TestC.Byte.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/TestC.Byte.cs
index 682a4dcebf6d..ff20036f2c7a 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/TestC.Byte.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/TestC.Byte.cs
@@ -329,7 +329,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -337,7 +337,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -374,13 +379,13 @@ private void ValidateResult(Byte[] left, Byte[] right, bool result, [CallerMembe
 
             if (expectedResult != result)
             {
-                Succeeded = false;
-
                 TestLibrary.TestFramework.LogInformation($"{nameof(Sse41)}.{nameof(Sse41.TestC)}<Byte>(Vector128<Byte>, Vector128<Byte>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/TestC.Int16.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/TestC.Int16.cs
index 7b9ca585c7d9..5ca469b11c40 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/TestC.Int16.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/TestC.Int16.cs
@@ -329,7 +329,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -337,7 +337,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -374,13 +379,13 @@ private void ValidateResult(Int16[] left, Int16[] right, bool result, [CallerMem
 
             if (expectedResult != result)
             {
-                Succeeded = false;
-
                 TestLibrary.TestFramework.LogInformation($"{nameof(Sse41)}.{nameof(Sse41.TestC)}<Int16>(Vector128<Int16>, Vector128<Int16>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/TestC.Int32.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/TestC.Int32.cs
index 5bba8ed2c634..f1de8b68359b 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/TestC.Int32.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/TestC.Int32.cs
@@ -329,7 +329,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -337,7 +337,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -374,13 +379,13 @@ private void ValidateResult(Int32[] left, Int32[] right, bool result, [CallerMem
 
             if (expectedResult != result)
             {
-                Succeeded = false;
-
                 TestLibrary.TestFramework.LogInformation($"{nameof(Sse41)}.{nameof(Sse41.TestC)}<Int32>(Vector128<Int32>, Vector128<Int32>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/TestC.Int64.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/TestC.Int64.cs
index 23454d957e86..5889454be5df 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/TestC.Int64.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/TestC.Int64.cs
@@ -329,7 +329,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -337,7 +337,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -374,13 +379,13 @@ private void ValidateResult(Int64[] left, Int64[] right, bool result, [CallerMem
 
             if (expectedResult != result)
             {
-                Succeeded = false;
-
                 TestLibrary.TestFramework.LogInformation($"{nameof(Sse41)}.{nameof(Sse41.TestC)}<Int64>(Vector128<Int64>, Vector128<Int64>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/TestC.SByte.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/TestC.SByte.cs
index 37ae5986ee97..a4342ba19624 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/TestC.SByte.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/TestC.SByte.cs
@@ -329,7 +329,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -337,7 +337,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -374,13 +379,13 @@ private void ValidateResult(SByte[] left, SByte[] right, bool result, [CallerMem
 
             if (expectedResult != result)
             {
-                Succeeded = false;
-
                 TestLibrary.TestFramework.LogInformation($"{nameof(Sse41)}.{nameof(Sse41.TestC)}<SByte>(Vector128<SByte>, Vector128<SByte>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/TestC.UInt16.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/TestC.UInt16.cs
index c510fb2397fa..175c6567d149 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/TestC.UInt16.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/TestC.UInt16.cs
@@ -329,7 +329,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -337,7 +337,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -374,13 +379,13 @@ private void ValidateResult(UInt16[] left, UInt16[] right, bool result, [CallerM
 
             if (expectedResult != result)
             {
-                Succeeded = false;
-
                 TestLibrary.TestFramework.LogInformation($"{nameof(Sse41)}.{nameof(Sse41.TestC)}<UInt16>(Vector128<UInt16>, Vector128<UInt16>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/TestC.UInt32.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/TestC.UInt32.cs
index b02ee854200d..162159b8c5b5 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/TestC.UInt32.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/TestC.UInt32.cs
@@ -329,7 +329,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -337,7 +337,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -374,13 +379,13 @@ private void ValidateResult(UInt32[] left, UInt32[] right, bool result, [CallerM
 
             if (expectedResult != result)
             {
-                Succeeded = false;
-
                 TestLibrary.TestFramework.LogInformation($"{nameof(Sse41)}.{nameof(Sse41.TestC)}<UInt32>(Vector128<UInt32>, Vector128<UInt32>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/TestC.UInt64.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/TestC.UInt64.cs
index d9307526b4bf..ade8dd8c6f37 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/TestC.UInt64.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/TestC.UInt64.cs
@@ -329,7 +329,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -337,7 +337,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -374,13 +379,13 @@ private void ValidateResult(UInt64[] left, UInt64[] right, bool result, [CallerM
 
             if (expectedResult != result)
             {
-                Succeeded = false;
-
                 TestLibrary.TestFramework.LogInformation($"{nameof(Sse41)}.{nameof(Sse41.TestC)}<UInt64>(Vector128<UInt64>, Vector128<UInt64>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/TestMixOnesZeros.Byte.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/TestMixOnesZeros.Byte.cs
index e6a5ef9de4d8..c2509ec475dd 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/TestMixOnesZeros.Byte.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/TestMixOnesZeros.Byte.cs
@@ -329,7 +329,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -337,7 +337,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -381,13 +386,13 @@ private void ValidateResult(Byte[] left, Byte[] right, bool result, [CallerMembe
 
             if (((expectedResult1 == false) && (expectedResult2 == false)) != result)
             {
-                Succeeded = false;
-
                 TestLibrary.TestFramework.LogInformation($"{nameof(Sse41)}.{nameof(Sse41.TestMixOnesZeros)}<Byte>(Vector128<Byte>, Vector128<Byte>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/TestMixOnesZeros.Int16.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/TestMixOnesZeros.Int16.cs
index e570fe8fd0ab..3f2a6eceb66a 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/TestMixOnesZeros.Int16.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/TestMixOnesZeros.Int16.cs
@@ -329,7 +329,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -337,7 +337,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -381,13 +386,13 @@ private void ValidateResult(Int16[] left, Int16[] right, bool result, [CallerMem
 
             if (((expectedResult1 == false) && (expectedResult2 == false)) != result)
             {
-                Succeeded = false;
-
                 TestLibrary.TestFramework.LogInformation($"{nameof(Sse41)}.{nameof(Sse41.TestMixOnesZeros)}<Int16>(Vector128<Int16>, Vector128<Int16>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/TestMixOnesZeros.Int32.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/TestMixOnesZeros.Int32.cs
index 7c31a5ac0974..0e5f130ce801 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/TestMixOnesZeros.Int32.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/TestMixOnesZeros.Int32.cs
@@ -329,7 +329,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -337,7 +337,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -381,13 +386,13 @@ private void ValidateResult(Int32[] left, Int32[] right, bool result, [CallerMem
 
             if (((expectedResult1 == false) && (expectedResult2 == false)) != result)
             {
-                Succeeded = false;
-
                 TestLibrary.TestFramework.LogInformation($"{nameof(Sse41)}.{nameof(Sse41.TestMixOnesZeros)}<Int32>(Vector128<Int32>, Vector128<Int32>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/TestMixOnesZeros.Int64.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/TestMixOnesZeros.Int64.cs
index bc8f56f7481f..9f2b53ba6142 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/TestMixOnesZeros.Int64.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/TestMixOnesZeros.Int64.cs
@@ -329,7 +329,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -337,7 +337,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -381,13 +386,13 @@ private void ValidateResult(Int64[] left, Int64[] right, bool result, [CallerMem
 
             if (((expectedResult1 == false) && (expectedResult2 == false)) != result)
             {
-                Succeeded = false;
-
                 TestLibrary.TestFramework.LogInformation($"{nameof(Sse41)}.{nameof(Sse41.TestMixOnesZeros)}<Int64>(Vector128<Int64>, Vector128<Int64>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/TestMixOnesZeros.SByte.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/TestMixOnesZeros.SByte.cs
index e18bd2c5d295..df6ad0e17a45 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/TestMixOnesZeros.SByte.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/TestMixOnesZeros.SByte.cs
@@ -329,7 +329,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -337,7 +337,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -381,13 +386,13 @@ private void ValidateResult(SByte[] left, SByte[] right, bool result, [CallerMem
 
             if (((expectedResult1 == false) && (expectedResult2 == false)) != result)
             {
-                Succeeded = false;
-
                 TestLibrary.TestFramework.LogInformation($"{nameof(Sse41)}.{nameof(Sse41.TestMixOnesZeros)}<SByte>(Vector128<SByte>, Vector128<SByte>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/TestMixOnesZeros.UInt16.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/TestMixOnesZeros.UInt16.cs
index 283ee9f60f15..35e2e1982b7a 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/TestMixOnesZeros.UInt16.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/TestMixOnesZeros.UInt16.cs
@@ -329,7 +329,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -337,7 +337,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -381,13 +386,13 @@ private void ValidateResult(UInt16[] left, UInt16[] right, bool result, [CallerM
 
             if (((expectedResult1 == false) && (expectedResult2 == false)) != result)
             {
-                Succeeded = false;
-
                 TestLibrary.TestFramework.LogInformation($"{nameof(Sse41)}.{nameof(Sse41.TestMixOnesZeros)}<UInt16>(Vector128<UInt16>, Vector128<UInt16>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/TestMixOnesZeros.UInt32.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/TestMixOnesZeros.UInt32.cs
index 5987502b12e3..9256682cbc46 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/TestMixOnesZeros.UInt32.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/TestMixOnesZeros.UInt32.cs
@@ -329,7 +329,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -337,7 +337,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -381,13 +386,13 @@ private void ValidateResult(UInt32[] left, UInt32[] right, bool result, [CallerM
 
             if (((expectedResult1 == false) && (expectedResult2 == false)) != result)
             {
-                Succeeded = false;
-
                 TestLibrary.TestFramework.LogInformation($"{nameof(Sse41)}.{nameof(Sse41.TestMixOnesZeros)}<UInt32>(Vector128<UInt32>, Vector128<UInt32>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/TestMixOnesZeros.UInt64.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/TestMixOnesZeros.UInt64.cs
index fe504ad75cc1..138c791e1f05 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/TestMixOnesZeros.UInt64.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/TestMixOnesZeros.UInt64.cs
@@ -329,7 +329,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -337,7 +337,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -381,13 +386,13 @@ private void ValidateResult(UInt64[] left, UInt64[] right, bool result, [CallerM
 
             if (((expectedResult1 == false) && (expectedResult2 == false)) != result)
             {
-                Succeeded = false;
-
                 TestLibrary.TestFramework.LogInformation($"{nameof(Sse41)}.{nameof(Sse41.TestMixOnesZeros)}<UInt64>(Vector128<UInt64>, Vector128<UInt64>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/TestNotZAndNotC.Byte.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/TestNotZAndNotC.Byte.cs
index b447b297a49d..a14625777338 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/TestNotZAndNotC.Byte.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/TestNotZAndNotC.Byte.cs
@@ -329,7 +329,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -337,7 +337,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -381,13 +386,13 @@ private void ValidateResult(Byte[] left, Byte[] right, bool result, [CallerMembe
 
             if (((expectedResult1 == false) && (expectedResult2 == false)) != result)
             {
-                Succeeded = false;
-
                 TestLibrary.TestFramework.LogInformation($"{nameof(Sse41)}.{nameof(Sse41.TestNotZAndNotC)}<Byte>(Vector128<Byte>, Vector128<Byte>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/TestNotZAndNotC.Int16.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/TestNotZAndNotC.Int16.cs
index 2e54f91262b7..43c6f925dec3 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/TestNotZAndNotC.Int16.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/TestNotZAndNotC.Int16.cs
@@ -329,7 +329,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -337,7 +337,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -381,13 +386,13 @@ private void ValidateResult(Int16[] left, Int16[] right, bool result, [CallerMem
 
             if (((expectedResult1 == false) && (expectedResult2 == false)) != result)
             {
-                Succeeded = false;
-
                 TestLibrary.TestFramework.LogInformation($"{nameof(Sse41)}.{nameof(Sse41.TestNotZAndNotC)}<Int16>(Vector128<Int16>, Vector128<Int16>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/TestNotZAndNotC.Int32.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/TestNotZAndNotC.Int32.cs
index d518e32875e5..25f622ed29f7 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/TestNotZAndNotC.Int32.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/TestNotZAndNotC.Int32.cs
@@ -329,7 +329,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -337,7 +337,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -381,13 +386,13 @@ private void ValidateResult(Int32[] left, Int32[] right, bool result, [CallerMem
 
             if (((expectedResult1 == false) && (expectedResult2 == false)) != result)
             {
-                Succeeded = false;
-
                 TestLibrary.TestFramework.LogInformation($"{nameof(Sse41)}.{nameof(Sse41.TestNotZAndNotC)}<Int32>(Vector128<Int32>, Vector128<Int32>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/TestNotZAndNotC.Int64.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/TestNotZAndNotC.Int64.cs
index ea893f91ff10..ca6cd0a186c8 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/TestNotZAndNotC.Int64.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/TestNotZAndNotC.Int64.cs
@@ -329,7 +329,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -337,7 +337,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -381,13 +386,13 @@ private void ValidateResult(Int64[] left, Int64[] right, bool result, [CallerMem
 
             if (((expectedResult1 == false) && (expectedResult2 == false)) != result)
             {
-                Succeeded = false;
-
                 TestLibrary.TestFramework.LogInformation($"{nameof(Sse41)}.{nameof(Sse41.TestNotZAndNotC)}<Int64>(Vector128<Int64>, Vector128<Int64>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/TestNotZAndNotC.SByte.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/TestNotZAndNotC.SByte.cs
index 0a4f3b6a0f2d..27031149891c 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/TestNotZAndNotC.SByte.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/TestNotZAndNotC.SByte.cs
@@ -329,7 +329,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -337,7 +337,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -381,13 +386,13 @@ private void ValidateResult(SByte[] left, SByte[] right, bool result, [CallerMem
 
             if (((expectedResult1 == false) && (expectedResult2 == false)) != result)
             {
-                Succeeded = false;
-
                 TestLibrary.TestFramework.LogInformation($"{nameof(Sse41)}.{nameof(Sse41.TestNotZAndNotC)}<SByte>(Vector128<SByte>, Vector128<SByte>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/TestNotZAndNotC.UInt16.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/TestNotZAndNotC.UInt16.cs
index 437609ee1e18..9687b275c0ed 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/TestNotZAndNotC.UInt16.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/TestNotZAndNotC.UInt16.cs
@@ -329,7 +329,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -337,7 +337,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -381,13 +386,13 @@ private void ValidateResult(UInt16[] left, UInt16[] right, bool result, [CallerM
 
             if (((expectedResult1 == false) && (expectedResult2 == false)) != result)
             {
-                Succeeded = false;
-
                 TestLibrary.TestFramework.LogInformation($"{nameof(Sse41)}.{nameof(Sse41.TestNotZAndNotC)}<UInt16>(Vector128<UInt16>, Vector128<UInt16>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/TestNotZAndNotC.UInt32.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/TestNotZAndNotC.UInt32.cs
index 6c2e65b0f6da..41c2c6630ada 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/TestNotZAndNotC.UInt32.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/TestNotZAndNotC.UInt32.cs
@@ -329,7 +329,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -337,7 +337,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -381,13 +386,13 @@ private void ValidateResult(UInt32[] left, UInt32[] right, bool result, [CallerM
 
             if (((expectedResult1 == false) && (expectedResult2 == false)) != result)
             {
-                Succeeded = false;
-
                 TestLibrary.TestFramework.LogInformation($"{nameof(Sse41)}.{nameof(Sse41.TestNotZAndNotC)}<UInt32>(Vector128<UInt32>, Vector128<UInt32>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/TestNotZAndNotC.UInt64.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/TestNotZAndNotC.UInt64.cs
index 95e9ea0bbb70..6a4ef41e5984 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/TestNotZAndNotC.UInt64.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/TestNotZAndNotC.UInt64.cs
@@ -329,7 +329,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -337,7 +337,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -381,13 +386,13 @@ private void ValidateResult(UInt64[] left, UInt64[] right, bool result, [CallerM
 
             if (((expectedResult1 == false) && (expectedResult2 == false)) != result)
             {
-                Succeeded = false;
-
                 TestLibrary.TestFramework.LogInformation($"{nameof(Sse41)}.{nameof(Sse41.TestNotZAndNotC)}<UInt64>(Vector128<UInt64>, Vector128<UInt64>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/TestZ.Byte.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/TestZ.Byte.cs
index 1fae6ed24e0e..cfd39b31e924 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/TestZ.Byte.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/TestZ.Byte.cs
@@ -329,7 +329,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -337,7 +337,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -374,13 +379,13 @@ private void ValidateResult(Byte[] left, Byte[] right, bool result, [CallerMembe
 
             if (expectedResult != result)
             {
-                Succeeded = false;
-
                 TestLibrary.TestFramework.LogInformation($"{nameof(Sse41)}.{nameof(Sse41.TestZ)}<Byte>(Vector128<Byte>, Vector128<Byte>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/TestZ.Int16.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/TestZ.Int16.cs
index 5949a02e2b25..04bc01e2135c 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/TestZ.Int16.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/TestZ.Int16.cs
@@ -329,7 +329,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -337,7 +337,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -374,13 +379,13 @@ private void ValidateResult(Int16[] left, Int16[] right, bool result, [CallerMem
 
             if (expectedResult != result)
             {
-                Succeeded = false;
-
                 TestLibrary.TestFramework.LogInformation($"{nameof(Sse41)}.{nameof(Sse41.TestZ)}<Int16>(Vector128<Int16>, Vector128<Int16>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/TestZ.Int32.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/TestZ.Int32.cs
index bee3666f50cf..d4201ca89174 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/TestZ.Int32.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/TestZ.Int32.cs
@@ -329,7 +329,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -337,7 +337,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -374,13 +379,13 @@ private void ValidateResult(Int32[] left, Int32[] right, bool result, [CallerMem
 
             if (expectedResult != result)
             {
-                Succeeded = false;
-
                 TestLibrary.TestFramework.LogInformation($"{nameof(Sse41)}.{nameof(Sse41.TestZ)}<Int32>(Vector128<Int32>, Vector128<Int32>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/TestZ.Int64.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/TestZ.Int64.cs
index e1a2eebc8d04..9391975dfc1b 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/TestZ.Int64.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/TestZ.Int64.cs
@@ -329,7 +329,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -337,7 +337,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -374,13 +379,13 @@ private void ValidateResult(Int64[] left, Int64[] right, bool result, [CallerMem
 
             if (expectedResult != result)
             {
-                Succeeded = false;
-
                 TestLibrary.TestFramework.LogInformation($"{nameof(Sse41)}.{nameof(Sse41.TestZ)}<Int64>(Vector128<Int64>, Vector128<Int64>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/TestZ.SByte.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/TestZ.SByte.cs
index 407acf104532..2dc9dc7b9368 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/TestZ.SByte.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/TestZ.SByte.cs
@@ -329,7 +329,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -337,7 +337,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -374,13 +379,13 @@ private void ValidateResult(SByte[] left, SByte[] right, bool result, [CallerMem
 
             if (expectedResult != result)
             {
-                Succeeded = false;
-
                 TestLibrary.TestFramework.LogInformation($"{nameof(Sse41)}.{nameof(Sse41.TestZ)}<SByte>(Vector128<SByte>, Vector128<SByte>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/TestZ.UInt16.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/TestZ.UInt16.cs
index 53f678f75a00..83e1090e6a55 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/TestZ.UInt16.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/TestZ.UInt16.cs
@@ -329,7 +329,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -337,7 +337,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -374,13 +379,13 @@ private void ValidateResult(UInt16[] left, UInt16[] right, bool result, [CallerM
 
             if (expectedResult != result)
             {
-                Succeeded = false;
-
                 TestLibrary.TestFramework.LogInformation($"{nameof(Sse41)}.{nameof(Sse41.TestZ)}<UInt16>(Vector128<UInt16>, Vector128<UInt16>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/TestZ.UInt32.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/TestZ.UInt32.cs
index 19b4147f451a..81ff6178286a 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/TestZ.UInt32.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/TestZ.UInt32.cs
@@ -329,7 +329,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -337,7 +337,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -374,13 +379,13 @@ private void ValidateResult(UInt32[] left, UInt32[] right, bool result, [CallerM
 
             if (expectedResult != result)
             {
-                Succeeded = false;
-
                 TestLibrary.TestFramework.LogInformation($"{nameof(Sse41)}.{nameof(Sse41.TestZ)}<UInt32>(Vector128<UInt32>, Vector128<UInt32>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/TestZ.UInt64.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/TestZ.UInt64.cs
index 5b61f56332e6..fc51152b8f0a 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/TestZ.UInt64.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/TestZ.UInt64.cs
@@ -329,7 +329,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -337,7 +337,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -374,13 +379,13 @@ private void ValidateResult(UInt64[] left, UInt64[] right, bool result, [CallerM
 
             if (expectedResult != result)
             {
-                Succeeded = false;
-
                 TestLibrary.TestFramework.LogInformation($"{nameof(Sse41)}.{nameof(Sse41.TestZ)}<UInt64>(Vector128<UInt64>, Vector128<UInt64>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse42/CompareGreaterThan.Int64.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse42/CompareGreaterThan.Int64.cs
index f3463bc3bfa4..92f0b33d6f8c 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Sse42/CompareGreaterThan.Int64.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse42/CompareGreaterThan.Int64.cs
@@ -334,7 +334,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -342,7 +342,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -374,9 +379,11 @@ private void ValidateResult(void* left, void* right, void* result, [CallerMember
 
         private void ValidateResult(Int64[] left, Int64[] right, Int64[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (result[0] != ((left[0] > right[0]) ? unchecked((long)(-1)) : 0))
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -384,19 +391,21 @@ private void ValidateResult(Int64[] left, Int64[] right, Int64[] result, [Caller
                 {
                     if (result[i] != ((left[i] > right[i]) ? unchecked((long)(-1)) : 0))
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Sse42)}.{nameof(Sse42.CompareGreaterThan)}<Int64>(Vector128<Int64>, Vector128<Int64>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Ssse3/Abs.Byte.cs b/tests/src/JIT/HardwareIntrinsics/X86/Ssse3/Abs.Byte.cs
index b90cab02acea..a86174ab63ea 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Ssse3/Abs.Byte.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Ssse3/Abs.Byte.cs
@@ -312,7 +312,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -320,7 +320,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -348,9 +353,11 @@ private void ValidateResult(void* firstOp, void* result, [CallerMemberName] stri
 
         private void ValidateResult(SByte[] firstOp, Byte[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (result[0] != Math.Abs(firstOp[0]))
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -358,18 +365,20 @@ private void ValidateResult(SByte[] firstOp, Byte[] result, [CallerMemberName] s
                 {
                     if (result[i] != Math.Abs(firstOp[i]))
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Ssse3)}.{nameof(Ssse3.Abs)}<Byte>(Vector128<SByte>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"  firstOp: ({string.Join(", ", firstOp)})");
                 TestLibrary.TestFramework.LogInformation($"   result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Ssse3/Abs.UInt16.cs b/tests/src/JIT/HardwareIntrinsics/X86/Ssse3/Abs.UInt16.cs
index cd6c4371f9ff..39d7c7e8ae2d 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Ssse3/Abs.UInt16.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Ssse3/Abs.UInt16.cs
@@ -312,7 +312,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -320,7 +320,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -348,9 +353,11 @@ private void ValidateResult(void* firstOp, void* result, [CallerMemberName] stri
 
         private void ValidateResult(Int16[] firstOp, UInt16[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (result[0] != Math.Abs(firstOp[0]))
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -358,18 +365,20 @@ private void ValidateResult(Int16[] firstOp, UInt16[] result, [CallerMemberName]
                 {
                     if (result[i] != Math.Abs(firstOp[i]))
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Ssse3)}.{nameof(Ssse3.Abs)}<UInt16>(Vector128<Int16>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"  firstOp: ({string.Join(", ", firstOp)})");
                 TestLibrary.TestFramework.LogInformation($"   result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Ssse3/Abs.UInt32.cs b/tests/src/JIT/HardwareIntrinsics/X86/Ssse3/Abs.UInt32.cs
index 3d692e376bf9..5a6935c34ff6 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Ssse3/Abs.UInt32.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Ssse3/Abs.UInt32.cs
@@ -312,7 +312,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -320,7 +320,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -348,9 +353,11 @@ private void ValidateResult(void* firstOp, void* result, [CallerMemberName] stri
 
         private void ValidateResult(Int32[] firstOp, UInt32[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (result[0] != Math.Abs(firstOp[0]))
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -358,18 +365,20 @@ private void ValidateResult(Int32[] firstOp, UInt32[] result, [CallerMemberName]
                 {
                     if (result[i] != Math.Abs(firstOp[i]))
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Ssse3)}.{nameof(Ssse3.Abs)}<UInt32>(Vector128<Int32>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"  firstOp: ({string.Join(", ", firstOp)})");
                 TestLibrary.TestFramework.LogInformation($"   result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Ssse3/AlignRight.Byte.0.cs b/tests/src/JIT/HardwareIntrinsics/X86/Ssse3/AlignRight.Byte.0.cs
index 604abbb6205f..e2a1681d59ea 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Ssse3/AlignRight.Byte.0.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Ssse3/AlignRight.Byte.0.cs
@@ -341,7 +341,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -349,7 +349,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -381,9 +386,11 @@ private void ValidateResult(void* left, void* right, void* result, [CallerMember
 
         private void ValidateResult(Byte[] left, Byte[] right, Byte[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (result[0] != right[0])
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -391,19 +398,21 @@ private void ValidateResult(Byte[] left, Byte[] right, Byte[] result, [CallerMem
                 {
                     if (result[i] != right[i])
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Ssse3)}.{nameof(Ssse3.AlignRight)}<Byte>(Vector128<Byte>.0, Vector128<Byte>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Ssse3/AlignRight.Byte.1.cs b/tests/src/JIT/HardwareIntrinsics/X86/Ssse3/AlignRight.Byte.1.cs
index 0bcffb08ef7b..23e102549db9 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Ssse3/AlignRight.Byte.1.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Ssse3/AlignRight.Byte.1.cs
@@ -341,7 +341,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -349,7 +349,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -381,9 +386,11 @@ private void ValidateResult(void* left, void* right, void* result, [CallerMember
 
         private void ValidateResult(Byte[] left, Byte[] right, Byte[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (result[0] != right[1])
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -391,19 +398,21 @@ private void ValidateResult(Byte[] left, Byte[] right, Byte[] result, [CallerMem
                 {
                     if (result[i] != (i == 15 ? left[0] : right[i+1]))
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Ssse3)}.{nameof(Ssse3.AlignRight)}<Byte>(Vector128<Byte>.1, Vector128<Byte>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Ssse3/AlignRight.Int16.0.cs b/tests/src/JIT/HardwareIntrinsics/X86/Ssse3/AlignRight.Int16.0.cs
index 07c1d2351d40..a9a78000b92d 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Ssse3/AlignRight.Int16.0.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Ssse3/AlignRight.Int16.0.cs
@@ -341,7 +341,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -349,7 +349,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -381,9 +386,11 @@ private void ValidateResult(void* left, void* right, void* result, [CallerMember
 
         private void ValidateResult(Int16[] left, Int16[] right, Int16[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (result[0] != right[0])
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -391,19 +398,21 @@ private void ValidateResult(Int16[] left, Int16[] right, Int16[] result, [Caller
                 {
                     if (result[i] != right[i])
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Ssse3)}.{nameof(Ssse3.AlignRight)}<Int16>(Vector128<Int16>.0, Vector128<Int16>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Ssse3/AlignRight.Int16.2.cs b/tests/src/JIT/HardwareIntrinsics/X86/Ssse3/AlignRight.Int16.2.cs
index 203c9fc8a4f4..0aafff7729a5 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Ssse3/AlignRight.Int16.2.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Ssse3/AlignRight.Int16.2.cs
@@ -341,7 +341,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -349,7 +349,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -381,9 +386,11 @@ private void ValidateResult(void* left, void* right, void* result, [CallerMember
 
         private void ValidateResult(Int16[] left, Int16[] right, Int16[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (result[0] != right[1])
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -391,19 +398,21 @@ private void ValidateResult(Int16[] left, Int16[] right, Int16[] result, [Caller
                 {
                     if (result[i] != (i == 7 ? left[0] : right[i+1]))
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Ssse3)}.{nameof(Ssse3.AlignRight)}<Int16>(Vector128<Int16>.2, Vector128<Int16>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Ssse3/AlignRight.Int32.0.cs b/tests/src/JIT/HardwareIntrinsics/X86/Ssse3/AlignRight.Int32.0.cs
index 72a15ee00431..fba8b82f29e4 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Ssse3/AlignRight.Int32.0.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Ssse3/AlignRight.Int32.0.cs
@@ -341,7 +341,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -349,7 +349,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -381,9 +386,11 @@ private void ValidateResult(void* left, void* right, void* result, [CallerMember
 
         private void ValidateResult(Int32[] left, Int32[] right, Int32[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (result[0] != right[0])
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -391,19 +398,21 @@ private void ValidateResult(Int32[] left, Int32[] right, Int32[] result, [Caller
                 {
                     if (result[i] != right[i])
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Ssse3)}.{nameof(Ssse3.AlignRight)}<Int32>(Vector128<Int32>.0, Vector128<Int32>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Ssse3/AlignRight.Int32.4.cs b/tests/src/JIT/HardwareIntrinsics/X86/Ssse3/AlignRight.Int32.4.cs
index d2e44fadf9dc..61f06b34ffad 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Ssse3/AlignRight.Int32.4.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Ssse3/AlignRight.Int32.4.cs
@@ -341,7 +341,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -349,7 +349,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -381,9 +386,11 @@ private void ValidateResult(void* left, void* right, void* result, [CallerMember
 
         private void ValidateResult(Int32[] left, Int32[] right, Int32[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (result[0] != right[1])
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -391,19 +398,21 @@ private void ValidateResult(Int32[] left, Int32[] right, Int32[] result, [Caller
                 {
                     if (result[i] != (i == 3 ? left[0] : right[i+1]))
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Ssse3)}.{nameof(Ssse3.AlignRight)}<Int32>(Vector128<Int32>.4, Vector128<Int32>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Ssse3/AlignRight.Int64.0.cs b/tests/src/JIT/HardwareIntrinsics/X86/Ssse3/AlignRight.Int64.0.cs
index 285049b5876b..bde02fa6203a 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Ssse3/AlignRight.Int64.0.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Ssse3/AlignRight.Int64.0.cs
@@ -341,7 +341,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -349,7 +349,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -381,9 +386,11 @@ private void ValidateResult(void* left, void* right, void* result, [CallerMember
 
         private void ValidateResult(Int64[] left, Int64[] right, Int64[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (result[0] != right[0])
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -391,19 +398,21 @@ private void ValidateResult(Int64[] left, Int64[] right, Int64[] result, [Caller
                 {
                     if (result[i] != right[i])
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Ssse3)}.{nameof(Ssse3.AlignRight)}<Int64>(Vector128<Int64>.0, Vector128<Int64>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Ssse3/AlignRight.Int64.8.cs b/tests/src/JIT/HardwareIntrinsics/X86/Ssse3/AlignRight.Int64.8.cs
index f01e124c7a3c..055765a88cf2 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Ssse3/AlignRight.Int64.8.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Ssse3/AlignRight.Int64.8.cs
@@ -341,7 +341,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -349,7 +349,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -381,9 +386,11 @@ private void ValidateResult(void* left, void* right, void* result, [CallerMember
 
         private void ValidateResult(Int64[] left, Int64[] right, Int64[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (result[0] != right[1])
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -391,19 +398,21 @@ private void ValidateResult(Int64[] left, Int64[] right, Int64[] result, [Caller
                 {
                     if (result[i] != (i == 1 ? left[0] : right[i+1]))
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Ssse3)}.{nameof(Ssse3.AlignRight)}<Int64>(Vector128<Int64>.8, Vector128<Int64>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Ssse3/AlignRight.SByte.0.cs b/tests/src/JIT/HardwareIntrinsics/X86/Ssse3/AlignRight.SByte.0.cs
index c50b0fdf29c4..0ee1aa31ec36 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Ssse3/AlignRight.SByte.0.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Ssse3/AlignRight.SByte.0.cs
@@ -341,7 +341,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -349,7 +349,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -381,9 +386,11 @@ private void ValidateResult(void* left, void* right, void* result, [CallerMember
 
         private void ValidateResult(SByte[] left, SByte[] right, SByte[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (result[0] != right[0])
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -391,19 +398,21 @@ private void ValidateResult(SByte[] left, SByte[] right, SByte[] result, [Caller
                 {
                     if (result[i] != right[i])
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Ssse3)}.{nameof(Ssse3.AlignRight)}<SByte>(Vector128<SByte>.0, Vector128<SByte>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Ssse3/AlignRight.SByte.1.cs b/tests/src/JIT/HardwareIntrinsics/X86/Ssse3/AlignRight.SByte.1.cs
index b865aa636ddf..52b7e9dd300f 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Ssse3/AlignRight.SByte.1.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Ssse3/AlignRight.SByte.1.cs
@@ -341,7 +341,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -349,7 +349,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -381,9 +386,11 @@ private void ValidateResult(void* left, void* right, void* result, [CallerMember
 
         private void ValidateResult(SByte[] left, SByte[] right, SByte[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (result[0] != right[1])
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -391,19 +398,21 @@ private void ValidateResult(SByte[] left, SByte[] right, SByte[] result, [Caller
                 {
                     if (result[i] != (i == 15 ? left[0] : right[i+1]))
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Ssse3)}.{nameof(Ssse3.AlignRight)}<SByte>(Vector128<SByte>.1, Vector128<SByte>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Ssse3/AlignRight.UInt16.0.cs b/tests/src/JIT/HardwareIntrinsics/X86/Ssse3/AlignRight.UInt16.0.cs
index f53d33b76993..31c8307cb366 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Ssse3/AlignRight.UInt16.0.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Ssse3/AlignRight.UInt16.0.cs
@@ -341,7 +341,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -349,7 +349,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -381,9 +386,11 @@ private void ValidateResult(void* left, void* right, void* result, [CallerMember
 
         private void ValidateResult(UInt16[] left, UInt16[] right, UInt16[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (result[0] != right[0])
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -391,19 +398,21 @@ private void ValidateResult(UInt16[] left, UInt16[] right, UInt16[] result, [Cal
                 {
                     if (result[i] != right[i])
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Ssse3)}.{nameof(Ssse3.AlignRight)}<UInt16>(Vector128<UInt16>.0, Vector128<UInt16>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Ssse3/AlignRight.UInt16.2.cs b/tests/src/JIT/HardwareIntrinsics/X86/Ssse3/AlignRight.UInt16.2.cs
index 0641e12554df..79097f15f46f 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Ssse3/AlignRight.UInt16.2.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Ssse3/AlignRight.UInt16.2.cs
@@ -341,7 +341,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -349,7 +349,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -381,9 +386,11 @@ private void ValidateResult(void* left, void* right, void* result, [CallerMember
 
         private void ValidateResult(UInt16[] left, UInt16[] right, UInt16[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (result[0] != right[1])
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -391,19 +398,21 @@ private void ValidateResult(UInt16[] left, UInt16[] right, UInt16[] result, [Cal
                 {
                     if (result[i] != (i == 7 ? left[0] : right[i+1]))
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Ssse3)}.{nameof(Ssse3.AlignRight)}<UInt16>(Vector128<UInt16>.2, Vector128<UInt16>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Ssse3/AlignRight.UInt32.0.cs b/tests/src/JIT/HardwareIntrinsics/X86/Ssse3/AlignRight.UInt32.0.cs
index 934a7216799c..15e12c0c34d9 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Ssse3/AlignRight.UInt32.0.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Ssse3/AlignRight.UInt32.0.cs
@@ -341,7 +341,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -349,7 +349,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -381,9 +386,11 @@ private void ValidateResult(void* left, void* right, void* result, [CallerMember
 
         private void ValidateResult(UInt32[] left, UInt32[] right, UInt32[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (result[0] != right[0])
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -391,19 +398,21 @@ private void ValidateResult(UInt32[] left, UInt32[] right, UInt32[] result, [Cal
                 {
                     if (result[i] != right[i])
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Ssse3)}.{nameof(Ssse3.AlignRight)}<UInt32>(Vector128<UInt32>.0, Vector128<UInt32>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Ssse3/AlignRight.UInt32.4.cs b/tests/src/JIT/HardwareIntrinsics/X86/Ssse3/AlignRight.UInt32.4.cs
index 0bcaa17959fd..d4c351f0eca7 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Ssse3/AlignRight.UInt32.4.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Ssse3/AlignRight.UInt32.4.cs
@@ -341,7 +341,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -349,7 +349,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -381,9 +386,11 @@ private void ValidateResult(void* left, void* right, void* result, [CallerMember
 
         private void ValidateResult(UInt32[] left, UInt32[] right, UInt32[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (result[0] != right[1])
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -391,19 +398,21 @@ private void ValidateResult(UInt32[] left, UInt32[] right, UInt32[] result, [Cal
                 {
                     if (result[i] != (i == 3 ? left[0] : right[i+1]))
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Ssse3)}.{nameof(Ssse3.AlignRight)}<UInt32>(Vector128<UInt32>.4, Vector128<UInt32>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Ssse3/AlignRight.UInt64.0.cs b/tests/src/JIT/HardwareIntrinsics/X86/Ssse3/AlignRight.UInt64.0.cs
index ab9fb0c47a86..07dd3cd0790a 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Ssse3/AlignRight.UInt64.0.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Ssse3/AlignRight.UInt64.0.cs
@@ -341,7 +341,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -349,7 +349,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -381,9 +386,11 @@ private void ValidateResult(void* left, void* right, void* result, [CallerMember
 
         private void ValidateResult(UInt64[] left, UInt64[] right, UInt64[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (result[0] != right[0])
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -391,19 +398,21 @@ private void ValidateResult(UInt64[] left, UInt64[] right, UInt64[] result, [Cal
                 {
                     if (result[i] != right[i])
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Ssse3)}.{nameof(Ssse3.AlignRight)}<UInt64>(Vector128<UInt64>.0, Vector128<UInt64>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Ssse3/AlignRight.UInt64.8.cs b/tests/src/JIT/HardwareIntrinsics/X86/Ssse3/AlignRight.UInt64.8.cs
index 475fb4cbd461..078b48f01b23 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Ssse3/AlignRight.UInt64.8.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Ssse3/AlignRight.UInt64.8.cs
@@ -341,7 +341,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -349,7 +349,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -381,9 +386,11 @@ private void ValidateResult(void* left, void* right, void* result, [CallerMember
 
         private void ValidateResult(UInt64[] left, UInt64[] right, UInt64[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (result[0] != right[1])
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -391,19 +398,21 @@ private void ValidateResult(UInt64[] left, UInt64[] right, UInt64[] result, [Cal
                 {
                     if (result[i] != (i == 1 ? left[0] : right[i+1]))
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Ssse3)}.{nameof(Ssse3.AlignRight)}<UInt64>(Vector128<UInt64>.8, Vector128<UInt64>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Ssse3/HorizontalAdd.Int16.cs b/tests/src/JIT/HardwareIntrinsics/X86/Ssse3/HorizontalAdd.Int16.cs
index f8fd6b8e9707..d80968db98ba 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Ssse3/HorizontalAdd.Int16.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Ssse3/HorizontalAdd.Int16.cs
@@ -334,7 +334,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -342,7 +342,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -374,6 +379,8 @@ private void ValidateResult(void* left, void* right, void* result, [CallerMember
 
         private void ValidateResult(Int16[] left, Int16[] right, Int16[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             for (var outer = 0; outer < (LargestVectorSize / 16); outer++)
             {
                 for (var inner = 0; inner < (8 / sizeof(Int16)); inner++)
@@ -384,25 +391,27 @@ private void ValidateResult(Int16[] left, Int16[] right, Int16[] result, [Caller
 
                     if (result[i1] != (short)(left[i3] + left[i3 + 1]))
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
 
                     if (result[i2] != (short)(right[i3] + right[i3 + 1]))
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Ssse3)}.{nameof(Ssse3.HorizontalAdd)}<Int16>(Vector128<Int16>, Vector128<Int16>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Ssse3/HorizontalAdd.Int32.cs b/tests/src/JIT/HardwareIntrinsics/X86/Ssse3/HorizontalAdd.Int32.cs
index 0e3e3b67246b..6c2153bfce0f 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Ssse3/HorizontalAdd.Int32.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Ssse3/HorizontalAdd.Int32.cs
@@ -334,7 +334,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -342,7 +342,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -374,6 +379,8 @@ private void ValidateResult(void* left, void* right, void* result, [CallerMember
 
         private void ValidateResult(Int32[] left, Int32[] right, Int32[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             for (var outer = 0; outer < (LargestVectorSize / 16); outer++)
             {
                 for (var inner = 0; inner < (8 / sizeof(Int32)); inner++)
@@ -384,25 +391,27 @@ private void ValidateResult(Int32[] left, Int32[] right, Int32[] result, [Caller
 
                     if (result[i1] != (int)(left[i3] + left[i3 + 1]))
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
 
                     if (result[i2] != (int)(right[i3] + right[i3 + 1]))
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Ssse3)}.{nameof(Ssse3.HorizontalAdd)}<Int32>(Vector128<Int32>, Vector128<Int32>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Ssse3/HorizontalAddSaturate.Int16.cs b/tests/src/JIT/HardwareIntrinsics/X86/Ssse3/HorizontalAddSaturate.Int16.cs
index 6727350d7de2..9b3f768cecbb 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Ssse3/HorizontalAddSaturate.Int16.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Ssse3/HorizontalAddSaturate.Int16.cs
@@ -334,7 +334,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -342,7 +342,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -374,6 +379,8 @@ private void ValidateResult(void* left, void* right, void* result, [CallerMember
 
         private void ValidateResult(Int16[] left, Int16[] right, Int16[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             for (var outer = 0; outer < (LargestVectorSize / 16); outer++)
             {
                 for (var inner = 0; inner < (8 / sizeof(Int16)); inner++)
@@ -384,25 +391,27 @@ private void ValidateResult(Int16[] left, Int16[] right, Int16[] result, [Caller
 
                     if (result[i1] != Math.Clamp((left[i3] + left[i3 + 1]), short.MinValue, short.MaxValue))
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
 
                     if (result[i2] != Math.Clamp((right[i3] + right[i3 + 1]), short.MinValue, short.MaxValue))
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Ssse3)}.{nameof(Ssse3.HorizontalAddSaturate)}<Int16>(Vector128<Int16>, Vector128<Int16>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Ssse3/HorizontalSubtract.Int16.cs b/tests/src/JIT/HardwareIntrinsics/X86/Ssse3/HorizontalSubtract.Int16.cs
index bb8b911c5945..c5dd828bdb59 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Ssse3/HorizontalSubtract.Int16.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Ssse3/HorizontalSubtract.Int16.cs
@@ -334,7 +334,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -342,7 +342,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -374,6 +379,8 @@ private void ValidateResult(void* left, void* right, void* result, [CallerMember
 
         private void ValidateResult(Int16[] left, Int16[] right, Int16[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             for (var outer = 0; outer < (LargestVectorSize / 16); outer++)
             {
                 for (var inner = 0; inner < (8 / sizeof(Int16)); inner++)
@@ -384,25 +391,27 @@ private void ValidateResult(Int16[] left, Int16[] right, Int16[] result, [Caller
 
                     if (result[i1] != (short)(left[i3] - left[i3 + 1]))
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
 
                     if (result[i2] != (short)(right[i3] - right[i3 + 1]))
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Ssse3)}.{nameof(Ssse3.HorizontalSubtract)}<Int16>(Vector128<Int16>, Vector128<Int16>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Ssse3/HorizontalSubtract.Int32.cs b/tests/src/JIT/HardwareIntrinsics/X86/Ssse3/HorizontalSubtract.Int32.cs
index 7531d80ee4a2..494a7490ec46 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Ssse3/HorizontalSubtract.Int32.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Ssse3/HorizontalSubtract.Int32.cs
@@ -334,7 +334,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -342,7 +342,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -374,6 +379,8 @@ private void ValidateResult(void* left, void* right, void* result, [CallerMember
 
         private void ValidateResult(Int32[] left, Int32[] right, Int32[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             for (var outer = 0; outer < (LargestVectorSize / 16); outer++)
             {
                 for (var inner = 0; inner < (8 / sizeof(Int32)); inner++)
@@ -384,25 +391,27 @@ private void ValidateResult(Int32[] left, Int32[] right, Int32[] result, [Caller
 
                     if (result[i1] != (int)(left[i3] - left[i3 + 1]))
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
 
                     if (result[i2] != (int)(right[i3] - right[i3 + 1]))
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Ssse3)}.{nameof(Ssse3.HorizontalSubtract)}<Int32>(Vector128<Int32>, Vector128<Int32>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Ssse3/HorizontalSubtractSaturate.Int16.cs b/tests/src/JIT/HardwareIntrinsics/X86/Ssse3/HorizontalSubtractSaturate.Int16.cs
index 2cd863d099ec..6766b25b30ac 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Ssse3/HorizontalSubtractSaturate.Int16.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Ssse3/HorizontalSubtractSaturate.Int16.cs
@@ -334,7 +334,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -342,7 +342,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -374,6 +379,8 @@ private void ValidateResult(void* left, void* right, void* result, [CallerMember
 
         private void ValidateResult(Int16[] left, Int16[] right, Int16[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             for (var outer = 0; outer < (LargestVectorSize / 16); outer++)
             {
                 for (var inner = 0; inner < (8 / sizeof(Int16)); inner++)
@@ -384,25 +391,27 @@ private void ValidateResult(Int16[] left, Int16[] right, Int16[] result, [Caller
 
                     if (result[i1] != Math.Clamp((left[i3] - left[i3 + 1]), short.MinValue, short.MaxValue))
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
 
                     if (result[i2] != Math.Clamp((right[i3] - right[i3 + 1]), short.MinValue, short.MaxValue))
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Ssse3)}.{nameof(Ssse3.HorizontalSubtractSaturate)}<Int16>(Vector128<Int16>, Vector128<Int16>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Ssse3/MultiplyAddAdjacent.Int16.cs b/tests/src/JIT/HardwareIntrinsics/X86/Ssse3/MultiplyAddAdjacent.Int16.cs
index dbaba18786bd..52f72b0e7a66 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Ssse3/MultiplyAddAdjacent.Int16.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Ssse3/MultiplyAddAdjacent.Int16.cs
@@ -334,7 +334,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -342,7 +342,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -374,9 +379,11 @@ private void ValidateResult(void* left, void* right, void* result, [CallerMember
 
         private void ValidateResult(Byte[] left, SByte[] right, Int16[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (result[0] != Math.Clamp(((right[1] * left[1]) + (right[0] * left[0])), short.MinValue, short.MaxValue))
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -384,19 +391,21 @@ private void ValidateResult(Byte[] left, SByte[] right, Int16[] result, [CallerM
                 {
                     if (result[i] != Math.Clamp(((right[(i * 2) + 1] * left[(i * 2) + 1]) + (right[i * 2] * left[i * 2])), short.MinValue, short.MaxValue))
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Ssse3)}.{nameof(Ssse3.MultiplyAddAdjacent)}<Int16>(Vector128<Byte>, Vector128<SByte>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Ssse3/MultiplyHighRoundScale.Int16.cs b/tests/src/JIT/HardwareIntrinsics/X86/Ssse3/MultiplyHighRoundScale.Int16.cs
index d9d5c50fdfa6..3caa767e9921 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Ssse3/MultiplyHighRoundScale.Int16.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Ssse3/MultiplyHighRoundScale.Int16.cs
@@ -334,7 +334,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -342,7 +342,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -374,9 +379,11 @@ private void ValidateResult(void* left, void* right, void* result, [CallerMember
 
         private void ValidateResult(Int16[] left, Int16[] right, Int16[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (result[0] != (short)((((left[0] * right[0]) >> 14) + 1) >> 1))
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -384,19 +391,21 @@ private void ValidateResult(Int16[] left, Int16[] right, Int16[] result, [Caller
                 {
                     if (result[i] != (short)((((left[i] * right[i]) >> 14) + 1) >> 1))
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Ssse3)}.{nameof(Ssse3.MultiplyHighRoundScale)}<Int16>(Vector128<Int16>, Vector128<Int16>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Ssse3/Shuffle.Byte.cs b/tests/src/JIT/HardwareIntrinsics/X86/Ssse3/Shuffle.Byte.cs
index 389ff16aac20..b8baa7a918dc 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Ssse3/Shuffle.Byte.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Ssse3/Shuffle.Byte.cs
@@ -334,7 +334,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -342,7 +342,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -374,9 +379,11 @@ private void ValidateResult(void* left, void* right, void* result, [CallerMember
 
         private void ValidateResult(Byte[] left, Byte[] right, Byte[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (result[0] != ((right[0] > 127) ? 0 : left[right[0] & 0x0F]))
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -384,19 +391,21 @@ private void ValidateResult(Byte[] left, Byte[] right, Byte[] result, [CallerMem
                 {
                     if (result[i] != ((right[i] > 127) ? 0 : left[right[i] & 0x0F]))
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Ssse3)}.{nameof(Ssse3.Shuffle)}<Byte>(Vector128<Byte>, Vector128<Byte>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Ssse3/Shuffle.SByte.cs b/tests/src/JIT/HardwareIntrinsics/X86/Ssse3/Shuffle.SByte.cs
index 44294761ef5f..a31a38e9fb06 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Ssse3/Shuffle.SByte.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Ssse3/Shuffle.SByte.cs
@@ -334,7 +334,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -342,7 +342,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -374,9 +379,11 @@ private void ValidateResult(void* left, void* right, void* result, [CallerMember
 
         private void ValidateResult(SByte[] left, SByte[] right, SByte[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (result[0] != ((right[0] < 0) ? 0 : left[right[0] & 0x0F]))
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -384,19 +391,21 @@ private void ValidateResult(SByte[] left, SByte[] right, SByte[] result, [Caller
                 {
                     if (result[i] != ((right[i] < 0) ? 0 : left[right[i] & 0x0F]))
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Ssse3)}.{nameof(Ssse3.Shuffle)}<SByte>(Vector128<SByte>, Vector128<SByte>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Ssse3/Sign.Int16.cs b/tests/src/JIT/HardwareIntrinsics/X86/Ssse3/Sign.Int16.cs
index 95adccd9ebfd..ad225dc20f5f 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Ssse3/Sign.Int16.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Ssse3/Sign.Int16.cs
@@ -334,7 +334,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -342,7 +342,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -374,9 +379,11 @@ private void ValidateResult(void* left, void* right, void* result, [CallerMember
 
         private void ValidateResult(Int16[] left, Int16[] right, Int16[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (result[0] != (right[0] < 0 ? (short)(-left[0]) : (right[0] > 0 ? left[0] : 0)))
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -384,19 +391,21 @@ private void ValidateResult(Int16[] left, Int16[] right, Int16[] result, [Caller
                 {
                     if (result[i] != (right[i] < 0 ? (short)(-left[i]) : (right[i] > 0 ? left[i] : 0)))
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Ssse3)}.{nameof(Ssse3.Sign)}<Int16>(Vector128<Int16>, Vector128<Int16>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Ssse3/Sign.Int32.cs b/tests/src/JIT/HardwareIntrinsics/X86/Ssse3/Sign.Int32.cs
index c702a093b262..d32e4dfe9127 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Ssse3/Sign.Int32.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Ssse3/Sign.Int32.cs
@@ -334,7 +334,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -342,7 +342,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -374,9 +379,11 @@ private void ValidateResult(void* left, void* right, void* result, [CallerMember
 
         private void ValidateResult(Int32[] left, Int32[] right, Int32[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (result[0] != (right[0] < 0 ? (int)(-left[0]) : (right[0] > 0 ? left[0] : 0)))
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -384,19 +391,21 @@ private void ValidateResult(Int32[] left, Int32[] right, Int32[] result, [Caller
                 {
                     if (result[i] != (right[i] < 0 ? (int)(-left[i]) : (right[i] > 0 ? left[i] : 0)))
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Ssse3)}.{nameof(Ssse3.Sign)}<Int32>(Vector128<Int32>, Vector128<Int32>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Ssse3/Sign.SByte.cs b/tests/src/JIT/HardwareIntrinsics/X86/Ssse3/Sign.SByte.cs
index d8b831324924..2d8088b391a8 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Ssse3/Sign.SByte.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Ssse3/Sign.SByte.cs
@@ -334,7 +334,7 @@ public void RunUnsupportedScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
 
-            Succeeded = false;
+            bool succeeded = false;
 
             try
             {
@@ -342,7 +342,12 @@ public void RunUnsupportedScenario()
             }
             catch (PlatformNotSupportedException)
             {
-                Succeeded = true;
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
             }
         }
 
@@ -374,9 +379,11 @@ private void ValidateResult(void* left, void* right, void* result, [CallerMember
 
         private void ValidateResult(SByte[] left, SByte[] right, SByte[] result, [CallerMemberName] string method = "")
         {
+            bool succeeded = true;
+
             if (result[0] != (right[0] < 0 ? (sbyte)(-left[0]) : (right[0] > 0 ? left[0] : 0)))
             {
-                Succeeded = false;
+                succeeded = false;
             }
             else
             {
@@ -384,19 +391,21 @@ private void ValidateResult(SByte[] left, SByte[] right, SByte[] result, [Caller
                 {
                     if (result[i] != (right[i] < 0 ? (sbyte)(-left[i]) : (right[i] > 0 ? left[i] : 0)))
                     {
-                        Succeeded = false;
+                        succeeded = false;
                         break;
                     }
                 }
             }
 
-            if (!Succeeded)
+            if (!succeeded)
             {
                 TestLibrary.TestFramework.LogInformation($"{nameof(Ssse3)}.{nameof(Ssse3.Sign)}<SByte>(Vector128<SByte>, Vector128<SByte>): {method} failed:");
                 TestLibrary.TestFramework.LogInformation($"    left: ({string.Join(", ", left)})");
                 TestLibrary.TestFramework.LogInformation($"   right: ({string.Join(", ", right)})");
                 TestLibrary.TestFramework.LogInformation($"  result: ({string.Join(", ", result)})");
                 TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
             }
         }
     }