Add Assert.Scope() for soft assertions

src/TestFramework/TestFramework/Assertions/Assert.AreSame.cs

@@ -1,4 +1,4 @@
-// Copyright (c) Microsoft Corporation. All rights reserved.
+// Copyright (c) Microsoft Corporation. All rights reserved.
 // Licensed under the MIT license. See LICENSE file in the project root for full license information.
 
 using System.ComponentModel;
@@ -39,7 +39,7 @@ internal void ComputeAssertion(string expectedExpression, string actualExpressio
             if (_builder is not null)
             {
                 _builder.Insert(0, string.Format(CultureInfo.CurrentCulture, FrameworkMessages.CallerArgumentExpressionTwoParametersMessage, "expected", expectedExpression, "actual", actualExpression) + " ");
-                ThrowAssertAreSameFailed(_expected, _actual, _builder.ToString());
+                ReportAssertAreSameFailed(_expected, _actual, _builder.ToString());
             }
         }
 
@@ -95,7 +95,7 @@ internal void ComputeAssertion(string notExpectedExpression, string actualExpres
             if (_builder is not null)
             {
                 _builder.Insert(0, string.Format(CultureInfo.CurrentCulture, FrameworkMessages.CallerArgumentExpressionTwoParametersMessage, "notExpected", notExpectedExpression, "actual", actualExpression) + " ");
-                ThrowAssertAreNotSameFailed(_builder.ToString());
+                ReportAssertAreNotSameFailed(_builder.ToString());
             }
         }
 
@@ -178,14 +178,14 @@ public static void AreSame<T>(T? expected, T? actual, string? message = "", [Cal
         }
 
         string userMessage = BuildUserMessageForExpectedExpressionAndActualExpression(message, expectedExpression, actualExpression);
-        ThrowAssertAreSameFailed(expected, actual, userMessage);
+        ReportAssertAreSameFailed(expected, actual, userMessage);
     }
 
     private static bool IsAreSameFailing<T>(T? expected, T? actual)
         => !object.ReferenceEquals(expected, actual);
 
     [DoesNotReturn]
-    private static void ThrowAssertAreSameFailed<T>(T? expected, T? actual, string userMessage)
+    private static void ReportAssertAreSameFailed<T>(T? expected, T? actual, string userMessage)
     {
         string finalMessage = userMessage;
         if (expected is ValueType && actual is ValueType)
@@ -196,7 +196,7 @@ private static void ThrowAssertAreSameFailed<T>(T? expected, T? actual, string u
                 userMessage);
         }
 
-        ThrowAssertFailed("Assert.AreSame", finalMessage);
+        ReportAssertFailed("Assert.AreSame", finalMessage);
     }
 
     /// <inheritdoc cref="AreNotSame{T}(T, T, string?, string, string)" />
@@ -240,14 +240,14 @@ public static void AreNotSame<T>(T? notExpected, T? actual, string? message = ""
     {
         if (IsAreNotSameFailing(notExpected, actual))
         {
-            ThrowAssertAreNotSameFailed(BuildUserMessageForNotExpectedExpressionAndActualExpression(message, notExpectedExpression, actualExpression));
+            ReportAssertAreNotSameFailed(BuildUserMessageForNotExpectedExpressionAndActualExpression(message, notExpectedExpression, actualExpression));
         }
     }
 
     private static bool IsAreNotSameFailing<T>(T? notExpected, T? actual)
         => object.ReferenceEquals(notExpected, actual);
 
     [DoesNotReturn]
-    private static void ThrowAssertAreNotSameFailed(string userMessage)
-        => ThrowAssertFailed("Assert.AreNotSame", userMessage);
+    private static void ReportAssertAreNotSameFailed(string userMessage)
+        => ReportAssertFailed("Assert.AreNotSame", userMessage);
 }

src/TestFramework/TestFramework/Assertions/Assert.Contains.cs

@@ -1,4 +1,4 @@
-// Copyright (c) Microsoft Corporation. All rights reserved.
+// Copyright (c) Microsoft Corporation. All rights reserved.
 // Licensed under the MIT license. See LICENSE file in the project root for full license information.
 
 using System.ComponentModel;
@@ -40,7 +40,7 @@ internal TItem ComputeAssertion(string collectionExpression)
             if (_builder is not null)
             {
                 _builder.Insert(0, string.Format(CultureInfo.CurrentCulture, FrameworkMessages.CallerArgumentExpressionSingleParameterMessage, "collection", collectionExpression) + " ");
-                ThrowAssertContainsSingleFailed(_actualCount, _builder.ToString());
+                ReportAssertContainsSingleFailed(_actualCount, _builder.ToString());
             }
 
             return _item!;
@@ -165,12 +165,12 @@ public static T ContainsSingle<T>(Func<T, bool> predicate, IEnumerable<T> collec
         if (string.IsNullOrEmpty(predicateExpression))
         {
             string userMessage = BuildUserMessageForCollectionExpression(message, collectionExpression);
-            ThrowAssertContainsSingleFailed(actualCount, userMessage);
+            ReportAssertContainsSingleFailed(actualCount, userMessage);
         }
         else
         {
             string userMessage = BuildUserMessageForPredicateExpressionAndCollectionExpression(message, predicateExpression, collectionExpression);
-            ThrowAssertSingleMatchFailed(actualCount, userMessage);
+            ReportAssertSingleMatchFailed(actualCount, userMessage);
         }
 
         // Unreachable code but compiler cannot work it out
@@ -226,12 +226,12 @@ public static T ContainsSingle<T>(Func<T, bool> predicate, IEnumerable<T> collec
         if (string.IsNullOrEmpty(predicateExpression))
         {
             string userMessage = BuildUserMessageForCollectionExpression(message, collectionExpression);
-            ThrowAssertContainsSingleFailed(matchCount, userMessage);
+            ReportAssertContainsSingleFailed(matchCount, userMessage);
         }
         else
         {
             string userMessage = BuildUserMessageForPredicateExpressionAndCollectionExpression(message, predicateExpression, collectionExpression);
-            ThrowAssertSingleMatchFailed(matchCount, userMessage);
+            ReportAssertSingleMatchFailed(matchCount, userMessage);
         }
 
         return default;
@@ -261,7 +261,7 @@ public static void Contains<T>(T expected, IEnumerable<T> collection, string? me
         if (!collection.Contains(expected))
         {
             string userMessage = BuildUserMessageForExpectedExpressionAndCollectionExpression(message, expectedExpression, collectionExpression);
-            ThrowAssertContainsItemFailed(userMessage);
+            ReportAssertContainsItemFailed(userMessage);
         }
     }
 
@@ -292,7 +292,7 @@ public static void Contains(object? expected, IEnumerable collection, string? me
         }
 
         string userMessage = BuildUserMessageForExpectedExpressionAndCollectionExpression(message, expectedExpression, collectionExpression);
-        ThrowAssertContainsItemFailed(userMessage);
+        ReportAssertContainsItemFailed(userMessage);
     }
 
     /// <summary>
@@ -316,7 +316,7 @@ public static void Contains<T>(T expected, IEnumerable<T> collection, IEqualityC
         if (!collection.Contains(expected, comparer))
         {
             string userMessage = BuildUserMessageForExpectedExpressionAndCollectionExpression(message, expectedExpression, collectionExpression);
-            ThrowAssertContainsItemFailed(userMessage);
+            ReportAssertContainsItemFailed(userMessage);
         }
     }
 
@@ -349,7 +349,7 @@ public static void Contains(object? expected, IEnumerable collection, IEqualityC
         }
 
         string userMessage = BuildUserMessageForExpectedExpressionAndCollectionExpression(message, expectedExpression, collectionExpression);
-        ThrowAssertContainsItemFailed(userMessage);
+        ReportAssertContainsItemFailed(userMessage);
     }
 
     /// <summary>
@@ -372,7 +372,7 @@ public static void Contains<T>(Func<T, bool> predicate, IEnumerable<T> collectio
         if (!collection.Any(predicate))
         {
             string userMessage = BuildUserMessageForPredicateExpressionAndCollectionExpression(message, predicateExpression, collectionExpression);
-            ThrowAssertContainsPredicateFailed(userMessage);
+            ReportAssertContainsPredicateFailed(userMessage);
         }
     }
 
@@ -404,7 +404,7 @@ public static void Contains(Func<object?, bool> predicate, IEnumerable collectio
         }
 
         string userMessage = BuildUserMessageForPredicateExpressionAndCollectionExpression(message, predicateExpression, collectionExpression);
-        ThrowAssertContainsPredicateFailed(userMessage);
+        ReportAssertContainsPredicateFailed(userMessage);
     }
 
     /// <summary>
@@ -478,7 +478,7 @@ public static void Contains(string substring, string value, StringComparison com
         {
             string userMessage = BuildUserMessageForSubstringExpressionAndValueExpression(message, substringExpression, valueExpression);
             string finalMessage = string.Format(CultureInfo.CurrentCulture, FrameworkMessages.ContainsFail, value, substring, userMessage);
-            ThrowAssertFailed("Assert.Contains", finalMessage);
+            ReportAssertFailed("Assert.Contains", finalMessage);
         }
     }
 
@@ -506,7 +506,7 @@ public static void DoesNotContain<T>(T notExpected, IEnumerable<T> collection, s
         if (collection.Contains(notExpected))
         {
             string userMessage = BuildUserMessageForNotExpectedExpressionAndCollectionExpression(message, notExpectedExpression, collectionExpression);
-            ThrowAssertDoesNotContainItemFailed(userMessage);
+            ReportAssertDoesNotContainItemFailed(userMessage);
         }
     }
 
@@ -533,7 +533,7 @@ public static void DoesNotContain(object? notExpected, IEnumerable collection, s
             if (object.Equals(notExpected, item))
             {
                 string userMessage = BuildUserMessageForNotExpectedExpressionAndCollectionExpression(message, notExpectedExpression, collectionExpression);
-                ThrowAssertDoesNotContainItemFailed(userMessage);
+                ReportAssertDoesNotContainItemFailed(userMessage);
             }
         }
     }
@@ -559,7 +559,7 @@ public static void DoesNotContain<T>(T notExpected, IEnumerable<T> collection, I
         if (collection.Contains(notExpected, comparer))
         {
             string userMessage = BuildUserMessageForNotExpectedExpressionAndCollectionExpression(message, notExpectedExpression, collectionExpression);
-            ThrowAssertDoesNotContainItemFailed(userMessage);
+            ReportAssertDoesNotContainItemFailed(userMessage);
         }
     }
 
@@ -588,7 +588,7 @@ public static void DoesNotContain(object? notExpected, IEnumerable collection, I
             if (comparer.Equals(item, notExpected))
             {
                 string userMessage = BuildUserMessageForNotExpectedExpressionAndCollectionExpression(message, notExpectedExpression, collectionExpression);
-                ThrowAssertDoesNotContainItemFailed(userMessage);
+                ReportAssertDoesNotContainItemFailed(userMessage);
             }
         }
     }
@@ -613,7 +613,7 @@ public static void DoesNotContain<T>(Func<T, bool> predicate, IEnumerable<T> col
         if (collection.Any(predicate))
         {
             string userMessage = BuildUserMessageForPredicateExpressionAndCollectionExpression(message, predicateExpression, collectionExpression);
-            ThrowAssertDoesNotContainPredicateFailed(userMessage);
+            ReportAssertDoesNotContainPredicateFailed(userMessage);
         }
     }
 
@@ -641,7 +641,7 @@ public static void DoesNotContain(Func<object?, bool> predicate, IEnumerable col
             if (predicate(item))
             {
                 string userMessage = BuildUserMessageForPredicateExpressionAndCollectionExpression(message, predicateExpression, collectionExpression);
-                ThrowAssertDoesNotContainPredicateFailed(userMessage);
+                ReportAssertDoesNotContainPredicateFailed(userMessage);
             }
         }
     }
@@ -717,7 +717,7 @@ public static void DoesNotContain(string substring, string value, StringComparis
         {
             string userMessage = BuildUserMessageForSubstringExpressionAndValueExpression(message, substringExpression, valueExpression);
             string finalMessage = string.Format(CultureInfo.CurrentCulture, FrameworkMessages.DoesNotContainFail, value, substring, userMessage);
-            ThrowAssertFailed("Assert.DoesNotContain", finalMessage);
+            ReportAssertFailed("Assert.DoesNotContain", finalMessage);
         }
     }
 
@@ -758,71 +758,71 @@ public static void IsInRange<T>(T minValue, T maxValue, T value, string? message
         {
             string userMessage = BuildUserMessageForMinValueExpressionAndMaxValueExpressionAndValueExpression(message, minValueExpression, maxValueExpression, valueExpression);
             string finalMessage = string.Format(CultureInfo.CurrentCulture, FrameworkMessages.IsInRangeFail, value, minValue, maxValue, userMessage);
-            ThrowAssertFailed("IsInRange", finalMessage);
+            ReportAssertFailed("IsInRange", finalMessage);
         }
     }
 
     #endregion // IsInRange
 
     [DoesNotReturn]
-    private static void ThrowAssertSingleMatchFailed(int actualCount, string userMessage)
+    private static void ReportAssertSingleMatchFailed(int actualCount, string userMessage)
     {
         string finalMessage = string.Format(
             CultureInfo.CurrentCulture,
             FrameworkMessages.ContainsSingleMatchFailMsg,
             userMessage,
             actualCount);
-        ThrowAssertFailed("Assert.ContainsSingle", finalMessage);
+        ReportAssertFailed("Assert.ContainsSingle", finalMessage);
     }
 
     [DoesNotReturn]
-    private static void ThrowAssertContainsSingleFailed(int actualCount, string userMessage)
+    private static void ReportAssertContainsSingleFailed(int actualCount, string userMessage)
     {
         string finalMessage = string.Format(
             CultureInfo.CurrentCulture,
             FrameworkMessages.ContainsSingleFailMsg,
             userMessage,
             actualCount);
-        ThrowAssertFailed("Assert.ContainsSingle", finalMessage);
+        ReportAssertFailed("Assert.ContainsSingle", finalMessage);
     }
 
     [DoesNotReturn]
-    private static void ThrowAssertContainsItemFailed(string userMessage)
+    private static void ReportAssertContainsItemFailed(string userMessage)
     {
         string finalMessage = string.Format(
             CultureInfo.CurrentCulture,
             FrameworkMessages.ContainsItemFailMsg,
             userMessage);
-        ThrowAssertFailed("Assert.Contains", finalMessage);
+        ReportAssertFailed("Assert.Contains", finalMessage);
     }
 
     [DoesNotReturn]
-    private static void ThrowAssertContainsPredicateFailed(string userMessage)
+    private static void ReportAssertContainsPredicateFailed(string userMessage)
     {
         string finalMessage = string.Format(
             CultureInfo.CurrentCulture,
             FrameworkMessages.ContainsPredicateFailMsg,
             userMessage);
-        ThrowAssertFailed("Assert.Contains", finalMessage);
+        ReportAssertFailed("Assert.Contains", finalMessage);
     }
 
     [DoesNotReturn]
-    private static void ThrowAssertDoesNotContainItemFailed(string userMessage)
+    private static void ReportAssertDoesNotContainItemFailed(string userMessage)
     {
         string finalMessage = string.Format(
             CultureInfo.CurrentCulture,
             FrameworkMessages.DoesNotContainItemFailMsg,
             userMessage);
-        ThrowAssertFailed("Assert.DoesNotContain", finalMessage);
+        ReportAssertFailed("Assert.DoesNotContain", finalMessage);
     }
 
     [DoesNotReturn]
-    private static void ThrowAssertDoesNotContainPredicateFailed(string userMessage)
+    private static void ReportAssertDoesNotContainPredicateFailed(string userMessage)
     {
         string finalMessage = string.Format(
             CultureInfo.CurrentCulture,
             FrameworkMessages.DoesNotContainPredicateFailMsg,
             userMessage);
-        ThrowAssertFailed("Assert.DoesNotContain", finalMessage);
+        ReportAssertFailed("Assert.DoesNotContain", finalMessage);
     }
 }