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

Sergio0694 · Sergio0694 · commit 5eb6a68b429e · 2025-11-07T14:56:47.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,9 @@ 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>(() => new ArrayPoolBufferWriter<byte>(-1));
     }
 
     [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,32 @@ 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>(() =>
+        {
+            using MemoryOwner<int>? buffer = MemoryOwner<int>.Allocate(-1);
+        });
     }
 
     [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,12 @@ 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>(() =>
+        {
+            using SpanOwner<int> buffer = SpanOwner<int>.Allocate(-1);
+        });
     }
 
     [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,16 @@ 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.ThrowsExactly<ArgumentOutOfRangeException>(() =>
+        {
+            ReadOnlySpan2D<int> span2d = new(array);
 
-        Assert.Fail();
+            _ = span2d[0..6, 2..^1];
+        });
     }
 #endif
 
@@ -690,7 +693,6 @@ public void Test_ReadOnlySpan2DT_ToArray_2()
     }
 
     [TestMethod]
-    [ExpectedException(typeof(NotSupportedException))]
     public void Test_ReadOnlySpan2DT_Equals()
     {
         int[,] array =
@@ -699,13 +701,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 +718,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,16 @@ 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.ThrowsExactly<ArgumentOutOfRangeException>(() =>
+        {
+            Span2D<int> span2d = new(array);
 
-        Assert.Fail();
+            _ = span2d[0..6, 2..^1];
+        });
     }
 #endif
 
@@ -882,7 +885,6 @@ public void Test_Span2DT_ToArray_2()
     }
 
     [TestMethod]
-    [ExpectedException(typeof(NotSupportedException))]
     public void Test_Span2DT_Equals()
     {
         int[,] array =
@@ -891,14 +893,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 +911,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

Original file line number	Diff line number	Diff line change
`@@ -137,12 +137,9 @@ 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`		`- _ = new ArrayPoolBufferWriter<byte>(-1);`
`144`		`-`
`145`		`- Assert.Fail("You shouldn't be here");`
	`142`	`+ _ = Assert.ThrowsExactly<ArgumentOutOfRangeException>(() => new ArrayPoolBufferWriter<byte>(-1));`
`146`	`143`	`}`
`147`	`144`
`148`	`145`	`[TestMethod]`
Original file line number	Diff line number	Diff line change
`@@ -51,34 +51,32 @@ 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`		`- using MemoryOwner<int>? buffer = MemoryOwner<int>.Allocate(-1);`
`58`		`-`
`59`		`- Assert.Fail("You shouldn't be here");`
	`56`	`+ _ = Assert.ThrowsExactly<ArgumentOutOfRangeException>(() =>`
	`57`	`+ {`
	`58`	`+ using MemoryOwner<int>? buffer = MemoryOwner<int>.Allocate(-1);`
	`59`	`+ });`
`60`	`60`	`}`
`61`	`61`
`62`	`62`	`[TestMethod]`
`63`		`- [ExpectedException(typeof(ObjectDisposedException))]`
`64`	`63`	`public void Test_MemoryOwnerOfT_DisposedMemory()`
`65`	`64`	`{`
`66`	`65`	`MemoryOwner<int>? buffer = MemoryOwner<int>.Allocate(127);`
`67`	`66`
`68`	`67`	`buffer.Dispose();`
`69`	`68`
`70`		`- _ = buffer.Memory;`
	`69`	`+ _ = Assert.ThrowsExactly<ObjectDisposedException>(() => _ = buffer.Memory);`
`71`	`70`	`}`
`72`	`71`
`73`	`72`	`[TestMethod]`
`74`		`- [ExpectedException(typeof(ObjectDisposedException))]`
`75`	`73`	`public void Test_MemoryOwnerOfT_DisposedSpan()`
`76`	`74`	`{`
`77`	`75`	`MemoryOwner<int>? buffer = MemoryOwner<int>.Allocate(127);`
`78`	`76`
`79`	`77`	`buffer.Dispose();`
`80`	`78`
`81`		`- _ = buffer.Span;`
	`79`	`+ _ = Assert.ThrowsExactly<ObjectDisposedException>(() => _ = buffer.Span);`
`82`	`80`	`}`
`83`	`81`
`84`	`82`	`[TestMethod]`
Original file line number	Diff line number	Diff line change
`@@ -47,12 +47,12 @@ 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`		`- using SpanOwner<int> buffer = SpanOwner<int>.Allocate(-1);`
`54`		`-`
`55`		`- Assert.Fail("You shouldn't be here");`
	`52`	`+ _ = Assert.ThrowsExactly<ArgumentOutOfRangeException>(() =>`
	`53`	`+ {`
	`54`	`+ using SpanOwner<int> buffer = SpanOwner<int>.Allocate(-1);`
	`55`	`+ });`
`56`	`56`	`}`
`57`	`57`
`58`	`58`	`[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]`