Don't use '[ExpectedException]' in HighPerformance tests

Sergio0694 · Sergio0694 · commit ee772528cb36 · 2025-11-07T13:39:44.000-08:00
diff --git a/tests/CommunityToolkit.HighPerformance.UnitTests/Buffers/Test_ArrayPoolBufferWriter{T}.cs b/tests/CommunityToolkit.HighPerformance.UnitTests/Buffers/Test_ArrayPoolBufferWriter{T}.cs
@@ -137,12 +137,11 @@ public void Test_ArrayPoolBufferWriterOfT_AllocateFromCustomPoolAndGetMemoryAndS
     }
 
     [TestMethod]
-    [ExpectedException(typeof(ArgumentOutOfRangeException))]
     public void Test_ArrayPoolBufferWriterOfT_InvalidRequestedSize()
     {
         _ = new ArrayPoolBufferWriter<byte>(-1);
 
-        Assert.Fail("You shouldn't be here");
+        _ = Assert.ThrowsExactly<ArgumentOutOfRangeException>(() => Assert.Fail("You shouldn't be here"));
     }
 
     [TestMethod]
diff --git a/tests/CommunityToolkit.HighPerformance.UnitTests/Buffers/Test_MemoryOwner{T}.cs b/tests/CommunityToolkit.HighPerformance.UnitTests/Buffers/Test_MemoryOwner{T}.cs
@@ -51,34 +51,31 @@ public void Test_MemoryOwnerOfT_AllocateFromCustomPoolAndGetMemoryAndSpan()
     }
 
     [TestMethod]
-    [ExpectedException(typeof(ArgumentOutOfRangeException))]
     public void Test_MemoryOwnerOfT_InvalidRequestedSize()
     {
         using MemoryOwner<int>? buffer = MemoryOwner<int>.Allocate(-1);
 
-        Assert.Fail("You shouldn't be here");
+        _ = Assert.ThrowsExactly<ArgumentOutOfRangeException>(() => Assert.Fail("You shouldn't be here"));
     }
 
     [TestMethod]
-    [ExpectedException(typeof(ObjectDisposedException))]
     public void Test_MemoryOwnerOfT_DisposedMemory()
     {
         MemoryOwner<int>? buffer = MemoryOwner<int>.Allocate(127);
 
         buffer.Dispose();
 
-        _ = buffer.Memory;
+        _ = Assert.ThrowsExactly<ObjectDisposedException>(() => _ = buffer.Memory);
     }
 
     [TestMethod]
-    [ExpectedException(typeof(ObjectDisposedException))]
     public void Test_MemoryOwnerOfT_DisposedSpan()
     {
         MemoryOwner<int>? buffer = MemoryOwner<int>.Allocate(127);
 
         buffer.Dispose();
 
-        _ = buffer.Span;
+        _ = Assert.ThrowsExactly<ObjectDisposedException>(() => _ = buffer.Span);
     }
 
     [TestMethod]
diff --git a/tests/CommunityToolkit.HighPerformance.UnitTests/Buffers/Test_SpanOwner{T}.cs b/tests/CommunityToolkit.HighPerformance.UnitTests/Buffers/Test_SpanOwner{T}.cs
@@ -47,12 +47,11 @@ public void Test_SpanOwnerOfT_AllocateFromCustomPoolAndGetMemoryAndSpan()
     }
 
     [TestMethod]
-    [ExpectedException(typeof(ArgumentOutOfRangeException))]
     public void Test_SpanOwnerOfT_InvalidRequestedSize()
     {
         using SpanOwner<int> buffer = SpanOwner<int>.Allocate(-1);
 
-        Assert.Fail("You shouldn't be here");
+        _ = Assert.ThrowsExactly<ArgumentOutOfRangeException>(() => Assert.Fail("You shouldn't be here"));
     }
 
     [TestMethod]
diff --git a/tests/CommunityToolkit.HighPerformance.UnitTests/Enumerables/Test_ReadOnlyRefEnumerable{T}.cs b/tests/CommunityToolkit.HighPerformance.UnitTests/Enumerables/Test_ReadOnlyRefEnumerable{T}.cs
@@ -39,10 +39,9 @@ public void Test_ReadOnlyRefEnumerable_DangerousCreate_Ok(int length, int step,
     [DataRow(-44, 10)]
     [DataRow(10, -14)]
     [DataRow(-32, -1)]
-    [ExpectedException(typeof(ArgumentOutOfRangeException))]
     public unsafe void Test_ReadOnlyRefEnumerable_DangerousCreate_BelowZero(int length, int step)
     {
-        _ = ReadOnlyRefEnumerable<int>.DangerousCreate(in *(int*)null, length, step);
+        _ = Assert.ThrowsExactly<ArgumentOutOfRangeException>(() => _ = ReadOnlyRefEnumerable<int>.DangerousCreate(in *(int*)null, length, step));
     }
 
     [TestMethod]
diff --git a/tests/CommunityToolkit.HighPerformance.UnitTests/Enumerables/Test_RefEnumerable{T}.cs b/tests/CommunityToolkit.HighPerformance.UnitTests/Enumerables/Test_RefEnumerable{T}.cs
@@ -39,10 +39,9 @@ public void Test_RefEnumerable_DangerousCreate_Ok(int length, int step, int[] va
     [DataRow(-44, 10)]
     [DataRow(10, -14)]
     [DataRow(-32, -1)]
-    [ExpectedException(typeof(ArgumentOutOfRangeException))]
     public unsafe void Test_RefEnumerable_DangerousCreate_BelowZero(int length, int step)
     {
-        _ = RefEnumerable<int>.DangerousCreate(ref *(int*)null, length, step);
+        _ = Assert.ThrowsExactly<ArgumentOutOfRangeException>(() => _ = RefEnumerable<int>.DangerousCreate(ref *(int*)null, length, step));
     }
 
     [TestMethod]
diff --git a/tests/CommunityToolkit.HighPerformance.UnitTests/Extensions/Test_ArrayPoolExtensions.cs b/tests/CommunityToolkit.HighPerformance.UnitTests/Extensions/Test_ArrayPoolExtensions.cs
@@ -14,12 +14,11 @@ namespace CommunityToolkit.HighPerformance.UnitTests.Extensions;
 public class Test_ArrayPoolExtensions
 {
     [TestMethod]
-    [ExpectedException(typeof(ArgumentOutOfRangeException))]
     public void Test_ArrayPoolExtensions_Resize_InvalidSize()
     {
         int[]? array = null;
 
-        ArrayPool<int>.Shared.Resize(ref array, -1);
+        _ = Assert.ThrowsExactly<ArgumentOutOfRangeException>(() => ArrayPool<int>.Shared.Resize(ref array, -1));
     }
 
     [TestMethod]
@@ -89,12 +88,11 @@ public void Test_ArrayPoolExtensions_Resize_Clear()
     }
 
     [TestMethod]
-    [ExpectedException(typeof(ArgumentOutOfRangeException))]
     public void Test_ArrayPoolExtensions_EnsureCapacity_InvalidCapacity()
     {
         int[]? array = null;
 
-        ArrayPool<int>.Shared.EnsureCapacity(ref array, -1);
+        _ = Assert.ThrowsExactly<ArgumentOutOfRangeException>(() => ArrayPool<int>.Shared.EnsureCapacity(ref array, -1));
     }
 
     [TestMethod]
diff --git a/tests/CommunityToolkit.HighPerformance.UnitTests/Helpers/Test_ParallelHelper.For.cs b/tests/CommunityToolkit.HighPerformance.UnitTests/Helpers/Test_ParallelHelper.For.cs
@@ -40,17 +40,15 @@ public unsafe void Test_ParallelHelper_ForWithIndices()
 
 #if NET6_0_OR_GREATER
     [TestMethod]
-    [ExpectedException(typeof(ArgumentException))]
     public void Test_ParallelHelper_ForInvalidRange_FromEnd()
     {
-        ParallelHelper.For<Assigner>(..^1);
+        _ = Assert.ThrowsExactly<ArgumentException>(() => ParallelHelper.For<Assigner>(..^1));
     }
 
     [TestMethod]
-    [ExpectedException(typeof(ArgumentException))]
     public void Test_ParallelHelper_ForInvalidRange_RangeAll()
     {
-        ParallelHelper.For<Assigner>(..);
+        _ = Assert.ThrowsExactly<ArgumentException>(() => ParallelHelper.For<Assigner>(..));
     }
 
     [TestMethod]
diff --git a/tests/CommunityToolkit.HighPerformance.UnitTests/Helpers/Test_ParallelHelper.For2D.cs b/tests/CommunityToolkit.HighPerformance.UnitTests/Helpers/Test_ParallelHelper.For2D.cs
@@ -52,17 +52,15 @@ public unsafe void Test_ParallelHelper_For2DWithIndices()
 
 #if NET6_0_OR_GREATER
     [TestMethod]
-    [ExpectedException(typeof(ArgumentException))]
     public void Test_ParallelHelper_For2DInvalidRange_FromEnd()
     {
-        ParallelHelper.For2D<Assigner2D>(..^1, ..4);
+        _ = Assert.ThrowsExactly<ArgumentException>(() => ParallelHelper.For2D<Assigner2D>(..^1, ..4));
     }
 
     [TestMethod]
-    [ExpectedException(typeof(ArgumentException))]
     public void Test_ParallelHelper_For2DInvalidRange_RangeAll()
     {
-        ParallelHelper.For2D<Assigner2D>(..5, ..);
+        _ = Assert.ThrowsExactly<ArgumentException>(() => ParallelHelper.For2D<Assigner2D>(..5, ..));
     }
 
     [TestMethod]
diff --git a/tests/CommunityToolkit.HighPerformance.UnitTests/Memory/Test_ReadOnlySpan2D{T}.cs b/tests/CommunityToolkit.HighPerformance.UnitTests/Memory/Test_ReadOnlySpan2D{T}.cs
@@ -417,14 +417,16 @@ public unsafe void Test_ReadOnlySpan2DT_Index_Indexer_2()
     }
 
     [TestMethod]
-    [ExpectedException(typeof(IndexOutOfRangeException))]
     public unsafe void Test_ReadOnlySpan2DT_Index_Indexer_Fail()
     {
         int[,] array = new int[4, 4];
 
-        ReadOnlySpan2D<int> span2d = new(array);
+        _ = Assert.ThrowsExactly<IndexOutOfRangeException>(() =>
+        {
+            ReadOnlySpan2D<int> span2d = new(array);
 
-        ref readonly int span2dRef = ref span2d[^6, 2];
+            ref readonly int span2dRef = ref span2d[^6, 2];
+        });
     }
 
     [TestMethod]
@@ -454,15 +456,14 @@ public unsafe void Test_ReadOnlySpan2DT_Range_Indexer_2()
     }
 
     [TestMethod]
-    [ExpectedException(typeof(ArgumentOutOfRangeException))]
     public unsafe void Test_ReadOnlySpan2DT_Range_Indexer_Fail()
     {
         int[,] array = new int[4, 4];
 
         ReadOnlySpan2D<int> span2d = new(array);
         _ = span2d[0..6, 2..^1];
 
-        Assert.Fail();
+        _ = Assert.ThrowsExactly<ArgumentOutOfRangeException>(() => Assert.Fail());
     }
 #endif
 
@@ -690,7 +691,6 @@ public void Test_ReadOnlySpan2DT_ToArray_2()
     }
 
     [TestMethod]
-    [ExpectedException(typeof(NotSupportedException))]
     public void Test_ReadOnlySpan2DT_Equals()
     {
         int[,] array =
@@ -699,13 +699,15 @@ public void Test_ReadOnlySpan2DT_Equals()
             { 4, 5, 6 }
         };
 
-        ReadOnlySpan2D<int> span2d = new(array);
+        _ = Assert.ThrowsExactly<NotSupportedException>(() =>
+        {
+            ReadOnlySpan2D<int> span2d = new(array);
 
-        _ = span2d.Equals(null);
+            _ = span2d.Equals(null);
+        });
     }
 
     [TestMethod]
-    [ExpectedException(typeof(NotSupportedException))]
     public void Test_ReadOnlySpan2DT_GetHashCode()
     {
         int[,] array =
@@ -714,9 +716,12 @@ public void Test_ReadOnlySpan2DT_GetHashCode()
             { 4, 5, 6 }
         };
 
-        ReadOnlySpan2D<int> span2d = new(array);
+        _ = Assert.ThrowsExactly<NotSupportedException>(() =>
+        {
+            ReadOnlySpan2D<int> span2d = new(array);
 
-        _ = span2d.GetHashCode();
+            _ = span2d.GetHashCode();
+        });
     }
 
     [TestMethod]
diff --git a/tests/CommunityToolkit.HighPerformance.UnitTests/Memory/Test_Span2D{T}.cs b/tests/CommunityToolkit.HighPerformance.UnitTests/Memory/Test_Span2D{T}.cs
@@ -574,14 +574,16 @@ public unsafe void Test_Span2DT_Index_Indexer_2()
     }
 
     [TestMethod]
-    [ExpectedException(typeof(IndexOutOfRangeException))]
     public unsafe void Test_Span2DT_Index_Indexer_Fail()
     {
         int[,] array = new int[4, 4];
 
-        Span2D<int> span2d = new(array);
+        _ = Assert.ThrowsExactly<IndexOutOfRangeException>(() =>
+        {
+            Span2D<int> span2d = new(array);
 
-        ref int span2dRef = ref span2d[^6, 2];
+            ref int span2dRef = ref span2d[^6, 2];
+        });
     }
 
     [TestMethod]
@@ -611,15 +613,14 @@ public unsafe void Test_Span2DT_Range_Indexer_2()
     }
 
     [TestMethod]
-    [ExpectedException(typeof(ArgumentOutOfRangeException))]
     public unsafe void Test_Span2DT_Range_Indexer_Fail()
     {
         int[,] array = new int[4, 4];
 
         Span2D<int> span2d = new(array);
         _ = span2d[0..6, 2..^1];
 
-        Assert.Fail();
+        _ = Assert.ThrowsExactly<ArgumentOutOfRangeException>(() => Assert.Fail());
     }
 #endif
 
@@ -882,7 +883,6 @@ public void Test_Span2DT_ToArray_2()
     }
 
     [TestMethod]
-    [ExpectedException(typeof(NotSupportedException))]
     public void Test_Span2DT_Equals()
     {
         int[,] array =
@@ -891,14 +891,16 @@ public void Test_Span2DT_Equals()
             { 4, 5, 6 }
         };
 
-        Span2D<int> span2d = new(array);
-
         // Span2D<T>.Equals always throw (this mirrors the behavior of Span<T>.Equals)
-        _ = span2d.Equals(null);
+        _ = Assert.ThrowsExactly<NotSupportedException>(() =>
+        {
+            Span2D<int> span2d = new(array);
+
+            _ = span2d.Equals(null);
+        });
     }
 
     [TestMethod]
-    [ExpectedException(typeof(NotSupportedException))]
     public void Test_Span2DT_GetHashCode()
     {
         int[,] array =
@@ -907,10 +909,13 @@ public void Test_Span2DT_GetHashCode()
             { 4, 5, 6 }
         };
 
-        Span2D<int> span2d = new(array);
-
         // Same as above, this always throws
-        _ = span2d.GetHashCode();
+        _ = Assert.ThrowsExactly<NotSupportedException>(() =>
+        {
+            Span2D<int> span2d = new(array);
+
+            _ = span2d.GetHashCode();
+        });
     }
 
     [TestMethod]
diff --git a/tests/CommunityToolkit.HighPerformance.UnitTests/Test_NullableReadOnlyRef{T}.cs b/tests/CommunityToolkit.HighPerformance.UnitTests/Test_NullableReadOnlyRef{T}.cs
@@ -34,12 +34,14 @@ public void Test_NullableReadOnlyRefOfT_CreateNullableReadOnlyRefOfT_Null()
     }
 
     [TestMethod]
-    [ExpectedException(typeof(InvalidOperationException))]
     public void Test_NullableReadOnlyRefOfT_CreateNullableReadOnlyRefOfT_Null_Exception()
     {
-        NullableReadOnlyRef<int> reference = default;
+        _ = Assert.ThrowsExactly<InvalidOperationException>(() =>
+        {
+            NullableReadOnlyRef<int> reference = default;
 
-        _ = reference.Value;
+            _ = reference.Value;
+        });
     }
 
     [TestMethod]
@@ -85,12 +87,14 @@ public void Test_NullableReadOnlyRefOfT_CreateNullableReadOnlyRefOfT_ExplicitCas
     }
 
     [TestMethod]
-    [ExpectedException(typeof(InvalidOperationException))]
     public void Test_NullableReadOnlyRefOfT_CreateNullableReadOnlyRefOfT_ExplicitCastOfT_Exception()
     {
-        NullableRef<int> invalid = default;
+        _ = Assert.ThrowsExactly<InvalidOperationException>(() =>
+        {
+            NullableRef<int> invalid = default;
 
-        _ = (int)invalid;
+            _ = (int)invalid;
+        });
     }
 }
 
diff --git a/tests/CommunityToolkit.HighPerformance.UnitTests/Test_NullableRef{T}.cs b/tests/CommunityToolkit.HighPerformance.UnitTests/Test_NullableRef{T}.cs
@@ -38,12 +38,14 @@ public void Test_NullableRefOfT_CreateNullableRefOfT_Null()
     }
 
     [TestMethod]
-    [ExpectedException(typeof(InvalidOperationException))]
     public void Test_NullableRefOfT_CreateNullableRefOfT_Null_Exception()
     {
-        NullableRef<int> reference = default;
+        _ = Assert.ThrowsExactly<InvalidOperationException>(() =>
+        {
+            NullableRef<int> reference = default;
 
-        _ = reference.Value;
+            _ = reference.Value;
+        });
     }
 
     [TestMethod]
@@ -67,12 +69,14 @@ public void Test_NullableRefOfT_CreateNullableRefOfT_ExplicitCastOfT()
     }
 
     [TestMethod]
-    [ExpectedException(typeof(InvalidOperationException))]
     public void Test_NullableRefOfT_CreateNullableRefOfT_ExplicitCastOfT_Exception()
     {
-        NullableRef<int> invalid = default;
+        _ = Assert.ThrowsExactly<InvalidOperationException>(() =>
+        {
+            NullableRef<int> invalid = default;
 
-        _ = (int)invalid;
+            _ = (int)invalid;
+        });
     }
 }
 

Original file line number	Diff line number	Diff line change
`@@ -137,12 +137,11 @@ public void Test_ArrayPoolBufferWriterOfT_AllocateFromCustomPoolAndGetMemoryAndS`
`137`	`137`	`}`
`138`	`138`
`139`	`139`	`[TestMethod]`
`140`		`- [ExpectedException(typeof(ArgumentOutOfRangeException))]`
`141`	`140`	`public void Test_ArrayPoolBufferWriterOfT_InvalidRequestedSize()`
`142`	`141`	`{`
`143`	`142`	`_ = new ArrayPoolBufferWriter<byte>(-1);`
`144`	`143`
`145`		`- Assert.Fail("You shouldn't be here");`
	`144`	`+ _ = Assert.ThrowsExactly<ArgumentOutOfRangeException>(() => Assert.Fail("You shouldn't be here"));`
`146`	`145`	`}`
`147`	`146`
`148`	`147`	`[TestMethod]`
Original file line number	Diff line number	Diff line change
`@@ -51,34 +51,31 @@ public void Test_MemoryOwnerOfT_AllocateFromCustomPoolAndGetMemoryAndSpan()`
`51`	`51`	`}`
`52`	`52`
`53`	`53`	`[TestMethod]`
`54`		`- [ExpectedException(typeof(ArgumentOutOfRangeException))]`
`55`	`54`	`public void Test_MemoryOwnerOfT_InvalidRequestedSize()`
`56`	`55`	`{`
`57`	`56`	`using MemoryOwner<int>? buffer = MemoryOwner<int>.Allocate(-1);`
`58`	`57`
`59`		`- Assert.Fail("You shouldn't be here");`
	`58`	`+ _ = Assert.ThrowsExactly<ArgumentOutOfRangeException>(() => Assert.Fail("You shouldn't be here"));`
`60`	`59`	`}`
`61`	`60`
`62`	`61`	`[TestMethod]`
`63`		`- [ExpectedException(typeof(ObjectDisposedException))]`
`64`	`62`	`public void Test_MemoryOwnerOfT_DisposedMemory()`
`65`	`63`	`{`
`66`	`64`	`MemoryOwner<int>? buffer = MemoryOwner<int>.Allocate(127);`
`67`	`65`
`68`	`66`	`buffer.Dispose();`
`69`	`67`
`70`		`- _ = buffer.Memory;`
	`68`	`+ _ = Assert.ThrowsExactly<ObjectDisposedException>(() => _ = buffer.Memory);`
`71`	`69`	`}`
`72`	`70`
`73`	`71`	`[TestMethod]`
`74`		`- [ExpectedException(typeof(ObjectDisposedException))]`
`75`	`72`	`public void Test_MemoryOwnerOfT_DisposedSpan()`
`76`	`73`	`{`
`77`	`74`	`MemoryOwner<int>? buffer = MemoryOwner<int>.Allocate(127);`
`78`	`75`
`79`	`76`	`buffer.Dispose();`
`80`	`77`
`81`		`- _ = buffer.Span;`
	`78`	`+ _ = Assert.ThrowsExactly<ObjectDisposedException>(() => _ = buffer.Span);`
`82`	`79`	`}`
`83`	`80`
`84`	`81`	`[TestMethod]`
Original file line number	Diff line number	Diff line change
`@@ -47,12 +47,11 @@ public void Test_SpanOwnerOfT_AllocateFromCustomPoolAndGetMemoryAndSpan()`
`47`	`47`	`}`
`48`	`48`
`49`	`49`	`[TestMethod]`
`50`		`- [ExpectedException(typeof(ArgumentOutOfRangeException))]`
`51`	`50`	`public void Test_SpanOwnerOfT_InvalidRequestedSize()`
`52`	`51`	`{`
`53`	`52`	`using SpanOwner<int> buffer = SpanOwner<int>.Allocate(-1);`
`54`	`53`
`55`		`- Assert.Fail("You shouldn't be here");`
	`54`	`+ _ = Assert.ThrowsExactly<ArgumentOutOfRangeException>(() => Assert.Fail("You shouldn't be here"));`
`56`	`55`	`}`
`57`	`56`
`58`	`57`	`[TestMethod]`
Original file line number	Diff line number	Diff line change
`@@ -39,10 +39,9 @@ public void Test_ReadOnlyRefEnumerable_DangerousCreate_Ok(int length, int step,`
`39`	`39`	`[DataRow(-44, 10)]`
`40`	`40`	`[DataRow(10, -14)]`
`41`	`41`	`[DataRow(-32, -1)]`
`42`		`- [ExpectedException(typeof(ArgumentOutOfRangeException))]`
`43`	`42`	`public unsafe void Test_ReadOnlyRefEnumerable_DangerousCreate_BelowZero(int length, int step)`
`44`	`43`	`{`
`45`		`- _ = ReadOnlyRefEnumerable<int>.DangerousCreate(in (int)null, length, step);`
	`44`	`+ _ = Assert.ThrowsExactly<ArgumentOutOfRangeException>(() => _ = ReadOnlyRefEnumerable<int>.DangerousCreate(in (int)null, length, step));`
`46`	`45`	`}`
`47`	`46`
`48`	`47`	`[TestMethod]`
Original file line number	Diff line number	Diff line change
`@@ -39,10 +39,9 @@ public void Test_RefEnumerable_DangerousCreate_Ok(int length, int step, int[] va`
`39`	`39`	`[DataRow(-44, 10)]`
`40`	`40`	`[DataRow(10, -14)]`
`41`	`41`	`[DataRow(-32, -1)]`
`42`		`- [ExpectedException(typeof(ArgumentOutOfRangeException))]`
`43`	`42`	`public unsafe void Test_RefEnumerable_DangerousCreate_BelowZero(int length, int step)`
`44`	`43`	`{`
`45`		`- _ = RefEnumerable<int>.DangerousCreate(ref (int)null, length, step);`
	`44`	`+ _ = Assert.ThrowsExactly<ArgumentOutOfRangeException>(() => _ = RefEnumerable<int>.DangerousCreate(ref (int)null, length, step));`
`46`	`45`	`}`
`47`	`46`
`48`	`47`	`[TestMethod]`
Original file line number	Diff line number	Diff line change
`@@ -14,12 +14,11 @@ namespace CommunityToolkit.HighPerformance.UnitTests.Extensions;`
`14`	`14`	`public class Test_ArrayPoolExtensions`
`15`	`15`	`{`
`16`	`16`	`[TestMethod]`
`17`		`- [ExpectedException(typeof(ArgumentOutOfRangeException))]`
`18`	`17`	`public void Test_ArrayPoolExtensions_Resize_InvalidSize()`
`19`	`18`	`{`
`20`	`19`	`int[]? array = null;`
`21`	`20`
`22`		`- ArrayPool<int>.Shared.Resize(ref array, -1);`
	`21`	`+ _ = Assert.ThrowsExactly<ArgumentOutOfRangeException>(() => ArrayPool<int>.Shared.Resize(ref array, -1));`
`23`	`22`	`}`
`24`	`23`
`25`	`24`	`[TestMethod]`
`@@ -89,12 +88,11 @@ public void Test_ArrayPoolExtensions_Resize_Clear()`
`89`	`88`	`}`
`90`	`89`
`91`	`90`	`[TestMethod]`
`92`		`- [ExpectedException(typeof(ArgumentOutOfRangeException))]`
`93`	`91`	`public void Test_ArrayPoolExtensions_EnsureCapacity_InvalidCapacity()`
`94`	`92`	`{`
`95`	`93`	`int[]? array = null;`
`96`	`94`
`97`		`- ArrayPool<int>.Shared.EnsureCapacity(ref array, -1);`
	`95`	`+ _ = Assert.ThrowsExactly<ArgumentOutOfRangeException>(() => ArrayPool<int>.Shared.EnsureCapacity(ref array, -1));`
`98`	`96`	`}`
`99`	`97`
`100`	`98`	`[TestMethod]`
Original file line number	Diff line number	Diff line change
`@@ -40,17 +40,15 @@ public unsafe void Test_ParallelHelper_ForWithIndices()`
`40`	`40`
`41`	`41`	`#if NET6_0_OR_GREATER`
`42`	`42`	`[TestMethod]`
`43`		`- [ExpectedException(typeof(ArgumentException))]`
`44`	`43`	`public void Test_ParallelHelper_ForInvalidRange_FromEnd()`
`45`	`44`	`{`
`46`		`- ParallelHelper.For<Assigner>(..^1);`
	`45`	`+ _ = Assert.ThrowsExactly<ArgumentException>(() => ParallelHelper.For<Assigner>(..^1));`
`47`	`46`	`}`
`48`	`47`
`49`	`48`	`[TestMethod]`
`50`		`- [ExpectedException(typeof(ArgumentException))]`
`51`	`49`	`public void Test_ParallelHelper_ForInvalidRange_RangeAll()`
`52`	`50`	`{`
`53`		`- ParallelHelper.For<Assigner>(..);`
	`51`	`+ _ = Assert.ThrowsExactly<ArgumentException>(() => ParallelHelper.For<Assigner>(..));`
`54`	`52`	`}`
`55`	`53`
`56`	`54`	`[TestMethod]`
Original file line number	Diff line number	Diff line change
`@@ -52,17 +52,15 @@ public unsafe void Test_ParallelHelper_For2DWithIndices()`
`52`	`52`
`53`	`53`	`#if NET6_0_OR_GREATER`
`54`	`54`	`[TestMethod]`
`55`		`- [ExpectedException(typeof(ArgumentException))]`
`56`	`55`	`public void Test_ParallelHelper_For2DInvalidRange_FromEnd()`
`57`	`56`	`{`
`58`		`- ParallelHelper.For2D<Assigner2D>(..^1, ..4);`
	`57`	`+ _ = Assert.ThrowsExactly<ArgumentException>(() => ParallelHelper.For2D<Assigner2D>(..^1, ..4));`
`59`	`58`	`}`
`60`	`59`
`61`	`60`	`[TestMethod]`
`62`		`- [ExpectedException(typeof(ArgumentException))]`
`63`	`61`	`public void Test_ParallelHelper_For2DInvalidRange_RangeAll()`
`64`	`62`	`{`
`65`		`- ParallelHelper.For2D<Assigner2D>(..5, ..);`
	`63`	`+ _ = Assert.ThrowsExactly<ArgumentException>(() => ParallelHelper.For2D<Assigner2D>(..5, ..));`
`66`	`64`	`}`
`67`	`65`
`68`	`66`	`[TestMethod]`