fix(tests): fix assertion and parameter compatibility issues

Nucs · Nucs · commit 5a4a4c0a5248 · 2026-04-15T18:47:42.000+03:00
- Convert Assert.ThrowsException&lt;Exception&gt; to Action.Should().Throw&lt;Exception&gt;()
  MSTest's ThrowsException requires exact type match, while AwesomeAssertions'
  Throw&lt;T&gt; accepts derived exception types (35 occurrences in 9 files)

- Remove CancellationToken parameter from ExtractShape_FromArray test
  TUnit injected cancellation tokens for timeout support; MSTest uses [Timeout] attribute

Test results: 5596 passed, 0 failed, 11 skipped
diff --git a/test/NumSharp.UnitTest/APIs/np.can_cast.BattleTest.cs b/test/NumSharp.UnitTest/APIs/np.can_cast.BattleTest.cs
@@ -106,7 +106,7 @@ public async Task CanCast_UnsafeMode_AllowsAnything()
     [TestMethod]
     public async Task CanCast_InvalidMode_Throws()
     {
-        Microsoft.VisualStudio.TestTools.UnitTesting.Assert.ThrowsException<Exception>(() => np.can_cast(NPTypeCode.Int32, NPTypeCode.Int64, "invalid"));
+        new Action(() => np.can_cast(NPTypeCode.Int32, NPTypeCode.Int64, "invalid")).Should().Throw<Exception>();
     }
 
     #endregion
diff --git a/test/NumSharp.UnitTest/APIs/np.common_type.BattleTest.cs b/test/NumSharp.UnitTest/APIs/np.common_type.BattleTest.cs
@@ -113,19 +113,19 @@ public async Task CommonType_Type_Float32_ReturnsSingle()
     [TestMethod]
     public async Task CommonType_Empty_Throws()
     {
-        Microsoft.VisualStudio.TestTools.UnitTesting.Assert.ThrowsException<Exception>(() => np.common_type_code(Array.Empty<NDArray>()));
+        new Action(() => np.common_type_code(Array.Empty<NDArray>())).Should().Throw<Exception>();
     }
 
     [TestMethod]
     public async Task CommonType_Null_Throws()
     {
-        Microsoft.VisualStudio.TestTools.UnitTesting.Assert.ThrowsException<Exception>(() => np.common_type_code((NDArray[])null!));
+        new Action(() => np.common_type_code((NDArray[])null!)).Should().Throw<Exception>();
     }
 
     [TestMethod]
     public async Task CommonTypeCode_Empty_Throws()
     {
-        Microsoft.VisualStudio.TestTools.UnitTesting.Assert.ThrowsException<Exception>(() => np.common_type_code(Array.Empty<NPTypeCode>()));
+        new Action(() => np.common_type_code(Array.Empty<NPTypeCode>())).Should().Throw<Exception>();
     }
 
     #endregion
diff --git a/test/NumSharp.UnitTest/APIs/np.finfo.BattleTest.cs b/test/NumSharp.UnitTest/APIs/np.finfo.BattleTest.cs
@@ -64,49 +64,49 @@ public async Task FInfo_Decimal_AllProperties()
     [TestMethod]
     public async Task FInfo_Int32_Throws()
     {
-        Microsoft.VisualStudio.TestTools.UnitTesting.Assert.ThrowsException<Exception>(() => np.finfo(NPTypeCode.Int32));
+        new Action(() => np.finfo(NPTypeCode.Int32)).Should().Throw<Exception>();
     }
 
     [TestMethod]
     public async Task FInfo_Boolean_Throws()
     {
-        Microsoft.VisualStudio.TestTools.UnitTesting.Assert.ThrowsException<Exception>(() => np.finfo(NPTypeCode.Boolean));
+        new Action(() => np.finfo(NPTypeCode.Boolean)).Should().Throw<Exception>();
     }
 
     [TestMethod]
     public async Task FInfo_Byte_Throws()
     {
-        Microsoft.VisualStudio.TestTools.UnitTesting.Assert.ThrowsException<Exception>(() => np.finfo(NPTypeCode.Byte));
+        new Action(() => np.finfo(NPTypeCode.Byte)).Should().Throw<Exception>();
     }
 
     [TestMethod]
     public async Task FInfo_Empty_Throws()
     {
-        Microsoft.VisualStudio.TestTools.UnitTesting.Assert.ThrowsException<Exception>(() => np.finfo(NPTypeCode.Empty));
+        new Action(() => np.finfo(NPTypeCode.Empty)).Should().Throw<Exception>();
     }
 
     [TestMethod]
     public async Task FInfo_NullType_Throws()
     {
-        Microsoft.VisualStudio.TestTools.UnitTesting.Assert.ThrowsException<Exception>(() => np.finfo((Type)null!));
+        new Action(() => np.finfo((Type)null!)).Should().Throw<Exception>();
     }
 
     [TestMethod]
     public async Task FInfo_NullArray_Throws()
     {
-        Microsoft.VisualStudio.TestTools.UnitTesting.Assert.ThrowsException<Exception>(() => np.finfo((NDArray)null!));
+        new Action(() => np.finfo((NDArray)null!)).Should().Throw<Exception>();
     }
 
     [TestMethod]
     public async Task FInfo_EmptyDtypeString_Throws()
     {
-        Microsoft.VisualStudio.TestTools.UnitTesting.Assert.ThrowsException<Exception>(() => np.finfo(""));
+        new Action(() => np.finfo("")).Should().Throw<Exception>();
     }
 
     [TestMethod]
     public async Task FInfo_InvalidDtypeString_Throws()
     {
-        Microsoft.VisualStudio.TestTools.UnitTesting.Assert.ThrowsException<Exception>(() => np.finfo("int32"));
+        new Action(() => np.finfo("int32")).Should().Throw<Exception>();
     }
 
     #endregion
@@ -139,7 +139,7 @@ public async Task FInfo_Generic_Decimal()
     [TestMethod]
     public async Task FInfo_Generic_Int_Throws()
     {
-        Microsoft.VisualStudio.TestTools.UnitTesting.Assert.ThrowsException<Exception>(() => np.finfo<int>());
+        new Action(() => np.finfo<int>()).Should().Throw<Exception>();
     }
 
     #endregion
@@ -166,7 +166,7 @@ public async Task FInfo_NDArray_Float64()
     public async Task FInfo_NDArray_Int_Throws()
     {
         var arr = np.array(new int[] { 1, 2, 3 });
-        Microsoft.VisualStudio.TestTools.UnitTesting.Assert.ThrowsException<Exception>(() => np.finfo(arr));
+        new Action(() => np.finfo(arr)).Should().Throw<Exception>();
     }
 
     #endregion
diff --git a/test/NumSharp.UnitTest/APIs/np.iinfo.BattleTest.cs b/test/NumSharp.UnitTest/APIs/np.iinfo.BattleTest.cs
@@ -112,49 +112,49 @@ public async Task IInfo_Char_AllProperties()
     [TestMethod]
     public async Task IInfo_Single_Throws()
     {
-        Microsoft.VisualStudio.TestTools.UnitTesting.Assert.ThrowsException<Exception>(() => np.iinfo(NPTypeCode.Single));
+        new Action(() => np.iinfo(NPTypeCode.Single)).Should().Throw<Exception>();
     }
 
     [TestMethod]
     public async Task IInfo_Double_Throws()
     {
-        Microsoft.VisualStudio.TestTools.UnitTesting.Assert.ThrowsException<Exception>(() => np.iinfo(NPTypeCode.Double));
+        new Action(() => np.iinfo(NPTypeCode.Double)).Should().Throw<Exception>();
     }
 
     [TestMethod]
     public async Task IInfo_Decimal_Throws()
     {
-        Microsoft.VisualStudio.TestTools.UnitTesting.Assert.ThrowsException<Exception>(() => np.iinfo(NPTypeCode.Decimal));
+        new Action(() => np.iinfo(NPTypeCode.Decimal)).Should().Throw<Exception>();
     }
 
     [TestMethod]
     public async Task IInfo_Empty_Throws()
     {
-        Microsoft.VisualStudio.TestTools.UnitTesting.Assert.ThrowsException<Exception>(() => np.iinfo(NPTypeCode.Empty));
+        new Action(() => np.iinfo(NPTypeCode.Empty)).Should().Throw<Exception>();
     }
 
     [TestMethod]
     public async Task IInfo_NullType_Throws()
     {
-        Microsoft.VisualStudio.TestTools.UnitTesting.Assert.ThrowsException<Exception>(() => np.iinfo((Type)null!));
+        new Action(() => np.iinfo((Type)null!)).Should().Throw<Exception>();
     }
 
     [TestMethod]
     public async Task IInfo_NullArray_Throws()
     {
-        Microsoft.VisualStudio.TestTools.UnitTesting.Assert.ThrowsException<Exception>(() => np.iinfo((NDArray)null!));
+        new Action(() => np.iinfo((NDArray)null!)).Should().Throw<Exception>();
     }
 
     [TestMethod]
     public async Task IInfo_EmptyDtypeString_Throws()
     {
-        Microsoft.VisualStudio.TestTools.UnitTesting.Assert.ThrowsException<Exception>(() => np.iinfo(""));
+        new Action(() => np.iinfo("")).Should().Throw<Exception>();
     }
 
     [TestMethod]
     public async Task IInfo_InvalidDtypeString_Throws()
     {
-        Microsoft.VisualStudio.TestTools.UnitTesting.Assert.ThrowsException<Exception>(() => np.iinfo("float32"));
+        new Action(() => np.iinfo("float32")).Should().Throw<Exception>();
     }
 
     #endregion
@@ -196,7 +196,7 @@ public async Task IInfo_Generic_Bool()
     [TestMethod]
     public async Task IInfo_Generic_Float_Throws()
     {
-        Microsoft.VisualStudio.TestTools.UnitTesting.Assert.ThrowsException<Exception>(() => np.iinfo<float>());
+        new Action(() => np.iinfo<float>()).Should().Throw<Exception>();
     }
 
     #endregion
@@ -224,7 +224,7 @@ public async Task IInfo_NDArray_Byte()
     public async Task IInfo_NDArray_Float_Throws()
     {
         var arr = np.array(new float[] { 1.0f, 2.0f });
-        Microsoft.VisualStudio.TestTools.UnitTesting.Assert.ThrowsException<Exception>(() => np.iinfo(arr));
+        new Action(() => np.iinfo(arr)).Should().Throw<Exception>();
     }
 
     #endregion
diff --git a/test/NumSharp.UnitTest/APIs/np.isreal_iscomplex.BattleTest.cs b/test/NumSharp.UnitTest/APIs/np.isreal_iscomplex.BattleTest.cs
@@ -48,7 +48,7 @@ public async Task IsReal_ShapeMatches()
     [TestMethod]
     public async Task IsReal_Null_Throws()
     {
-        Microsoft.VisualStudio.TestTools.UnitTesting.Assert.ThrowsException<Exception>(() => np.isreal(null!));
+        new Action(() => np.isreal(null!)).Should().Throw<Exception>();
     }
 
     #endregion
@@ -84,7 +84,7 @@ public async Task IsComplex_ShapeMatches()
     [TestMethod]
     public async Task IsComplex_Null_Throws()
     {
-        Microsoft.VisualStudio.TestTools.UnitTesting.Assert.ThrowsException<Exception>(() => np.iscomplex(null!));
+        new Action(() => np.iscomplex(null!)).Should().Throw<Exception>();
     }
 
     #endregion
@@ -125,7 +125,7 @@ public async Task IsRealObj_AllTypes_True()
     [TestMethod]
     public async Task IsRealObj_Null_Throws()
     {
-        Microsoft.VisualStudio.TestTools.UnitTesting.Assert.ThrowsException<Exception>(() => np.isrealobj(null!));
+        new Action(() => np.isrealobj(null!)).Should().Throw<Exception>();
     }
 
     #endregion
@@ -158,7 +158,7 @@ public async Task IsComplexObj_AllRealTypes_False()
     [TestMethod]
     public async Task IsComplexObj_Null_Throws()
     {
-        Microsoft.VisualStudio.TestTools.UnitTesting.Assert.ThrowsException<Exception>(() => np.iscomplexobj(null!));
+        new Action(() => np.iscomplexobj(null!)).Should().Throw<Exception>();
     }
 
     #endregion
diff --git a/test/NumSharp.UnitTest/APIs/np.issubdtype.BattleTest.cs b/test/NumSharp.UnitTest/APIs/np.issubdtype.BattleTest.cs
@@ -123,7 +123,7 @@ public async Task IsSubdtype_NDArray_String()
     [TestMethod]
     public async Task IsSubdtype_NDArray_Null_Throws()
     {
-        Microsoft.VisualStudio.TestTools.UnitTesting.Assert.ThrowsException<Exception>(() => np.issubdtype((NDArray)null!, "integer"));
+        new Action(() => np.issubdtype((NDArray)null!, "integer")).Should().Throw<Exception>();
     }
 
     #endregion
diff --git a/test/NumSharp.UnitTest/APIs/np.min_scalar_type.BattleTest.cs b/test/NumSharp.UnitTest/APIs/np.min_scalar_type.BattleTest.cs
@@ -136,7 +136,7 @@ public async Task MinScalarType_Decimal()
     [TestMethod]
     public async Task MinScalarType_Null_Throws()
     {
-        Microsoft.VisualStudio.TestTools.UnitTesting.Assert.ThrowsException<Exception>(() => np.min_scalar_type(null!));
+        new Action(() => np.min_scalar_type(null!)).Should().Throw<Exception>();
     }
 
     #endregion
diff --git a/test/NumSharp.UnitTest/APIs/np.result_type.BattleTest.cs b/test/NumSharp.UnitTest/APIs/np.result_type.BattleTest.cs
@@ -58,13 +58,13 @@ public async Task ResultType_Float32Float64_ReturnsFloat64()
     [TestMethod]
     public async Task ResultType_Empty_Throws()
     {
-        Microsoft.VisualStudio.TestTools.UnitTesting.Assert.ThrowsException<Exception>(() => np.result_type(Array.Empty<NPTypeCode>()));
+        new Action(() => np.result_type(Array.Empty<NPTypeCode>())).Should().Throw<Exception>();
     }
 
     [TestMethod]
     public async Task ResultType_NullArray_Throws()
     {
-        Microsoft.VisualStudio.TestTools.UnitTesting.Assert.ThrowsException<Exception>(() => np.result_type((NPTypeCode[])null!));
+        new Action(() => np.result_type((NPTypeCode[])null!)).Should().Throw<Exception>();
     }
 
     #endregion
@@ -95,14 +95,14 @@ public async Task ResultType_TwoArg_NDArray()
     public async Task ResultType_TwoArg_NDArray_NullFirst_Throws()
     {
         var b = np.array(new int[] { 1, 2 });
-        Microsoft.VisualStudio.TestTools.UnitTesting.Assert.ThrowsException<Exception>(() => np.result_type((NDArray)null!, b));
+        new Action(() => np.result_type((NDArray)null!, b)).Should().Throw<Exception>();
     }
 
     [TestMethod]
     public async Task ResultType_TwoArg_NDArray_NullSecond_Throws()
     {
         var a = np.array(new int[] { 1, 2 });
-        Microsoft.VisualStudio.TestTools.UnitTesting.Assert.ThrowsException<Exception>(() => np.result_type(a, (NDArray)null!));
+        new Action(() => np.result_type(a, (NDArray)null!)).Should().Throw<Exception>();
     }
 
     #endregion
diff --git a/test/NumSharp.UnitTest/APIs/np.type_checks.BattleTest.cs b/test/NumSharp.UnitTest/APIs/np.type_checks.BattleTest.cs
@@ -113,7 +113,7 @@ public async Task IsDtype_NDArray_Integral()
     [TestMethod]
     public async Task IsDtype_NDArray_Null_Throws()
     {
-        Microsoft.VisualStudio.TestTools.UnitTesting.Assert.ThrowsException<Exception>(() => np.isdtype((NDArray)null!, "integral"));
+        new Action(() => np.isdtype((NDArray)null!, "integral")).Should().Throw<Exception>();
     }
 
     #endregion
diff --git a/test/NumSharp.UnitTest/View/Shape.Test.cs b/test/NumSharp.UnitTest/View/Shape.Test.cs
@@ -94,7 +94,7 @@ public void EqualityComparer()
 
 
         [TestMethod, Timeout(10000)]
-        public void ExtractShape_FromArray(CancellationToken cancellationToken)
+        public void ExtractShape_FromArray()
         {
             // @formatter:off — disable formatter after this line
             var v = Shape.ExtractShape((Array)new int[][][]

Original file line number	Diff line number	Diff line change
`@@ -106,7 +106,7 @@ public async Task CanCast_UnsafeMode_AllowsAnything()`
`106`	`106`	`[TestMethod]`
`107`	`107`	`public async Task CanCast_InvalidMode_Throws()`
`108`	`108`	`{`
`109`		`- Microsoft.VisualStudio.TestTools.UnitTesting.Assert.ThrowsException<Exception>(() => np.can_cast(NPTypeCode.Int32, NPTypeCode.Int64, "invalid"));`
	`109`	`+ new Action(() => np.can_cast(NPTypeCode.Int32, NPTypeCode.Int64, "invalid")).Should().Throw<Exception>();`
`110`	`110`	`}`
`111`	`111`
`112`	`112`	`#endregion`
Original file line number	Diff line number	Diff line change
`@@ -113,19 +113,19 @@ public async Task CommonType_Type_Float32_ReturnsSingle()`
`113`	`113`	`[TestMethod]`
`114`	`114`	`public async Task CommonType_Empty_Throws()`
`115`	`115`	`{`
`116`		`- Microsoft.VisualStudio.TestTools.UnitTesting.Assert.ThrowsException<Exception>(() => np.common_type_code(Array.Empty<NDArray>()));`
	`116`	`+ new Action(() => np.common_type_code(Array.Empty<NDArray>())).Should().Throw<Exception>();`
`117`	`117`	`}`
`118`	`118`
`119`	`119`	`[TestMethod]`
`120`	`120`	`public async Task CommonType_Null_Throws()`
`121`	`121`	`{`
`122`		`- Microsoft.VisualStudio.TestTools.UnitTesting.Assert.ThrowsException<Exception>(() => np.common_type_code((NDArray[])null!));`
	`122`	`+ new Action(() => np.common_type_code((NDArray[])null!)).Should().Throw<Exception>();`
`123`	`123`	`}`
`124`	`124`
`125`	`125`	`[TestMethod]`
`126`	`126`	`public async Task CommonTypeCode_Empty_Throws()`
`127`	`127`	`{`
`128`		`- Microsoft.VisualStudio.TestTools.UnitTesting.Assert.ThrowsException<Exception>(() => np.common_type_code(Array.Empty<NPTypeCode>()));`
	`128`	`+ new Action(() => np.common_type_code(Array.Empty<NPTypeCode>())).Should().Throw<Exception>();`
`129`	`129`	`}`
`130`	`130`
`131`	`131`	`#endregion`
Original file line number	Diff line number	Diff line change
`@@ -64,49 +64,49 @@ public async Task FInfo_Decimal_AllProperties()`
`64`	`64`	`[TestMethod]`
`65`	`65`	`public async Task FInfo_Int32_Throws()`
`66`	`66`	`{`
`67`		`- Microsoft.VisualStudio.TestTools.UnitTesting.Assert.ThrowsException<Exception>(() => np.finfo(NPTypeCode.Int32));`
	`67`	`+ new Action(() => np.finfo(NPTypeCode.Int32)).Should().Throw<Exception>();`
`68`	`68`	`}`
`69`	`69`
`70`	`70`	`[TestMethod]`
`71`	`71`	`public async Task FInfo_Boolean_Throws()`
`72`	`72`	`{`
`73`		`- Microsoft.VisualStudio.TestTools.UnitTesting.Assert.ThrowsException<Exception>(() => np.finfo(NPTypeCode.Boolean));`
	`73`	`+ new Action(() => np.finfo(NPTypeCode.Boolean)).Should().Throw<Exception>();`
`74`	`74`	`}`
`75`	`75`
`76`	`76`	`[TestMethod]`
`77`	`77`	`public async Task FInfo_Byte_Throws()`
`78`	`78`	`{`
`79`		`- Microsoft.VisualStudio.TestTools.UnitTesting.Assert.ThrowsException<Exception>(() => np.finfo(NPTypeCode.Byte));`
	`79`	`+ new Action(() => np.finfo(NPTypeCode.Byte)).Should().Throw<Exception>();`
`80`	`80`	`}`
`81`	`81`
`82`	`82`	`[TestMethod]`
`83`	`83`	`public async Task FInfo_Empty_Throws()`
`84`	`84`	`{`
`85`		`- Microsoft.VisualStudio.TestTools.UnitTesting.Assert.ThrowsException<Exception>(() => np.finfo(NPTypeCode.Empty));`
	`85`	`+ new Action(() => np.finfo(NPTypeCode.Empty)).Should().Throw<Exception>();`
`86`	`86`	`}`
`87`	`87`
`88`	`88`	`[TestMethod]`
`89`	`89`	`public async Task FInfo_NullType_Throws()`
`90`	`90`	`{`
`91`		`- Microsoft.VisualStudio.TestTools.UnitTesting.Assert.ThrowsException<Exception>(() => np.finfo((Type)null!));`
	`91`	`+ new Action(() => np.finfo((Type)null!)).Should().Throw<Exception>();`
`92`	`92`	`}`
`93`	`93`
`94`	`94`	`[TestMethod]`
`95`	`95`	`public async Task FInfo_NullArray_Throws()`
`96`	`96`	`{`
`97`		`- Microsoft.VisualStudio.TestTools.UnitTesting.Assert.ThrowsException<Exception>(() => np.finfo((NDArray)null!));`
	`97`	`+ new Action(() => np.finfo((NDArray)null!)).Should().Throw<Exception>();`
`98`	`98`	`}`
`99`	`99`
`100`	`100`	`[TestMethod]`
`101`	`101`	`public async Task FInfo_EmptyDtypeString_Throws()`
`102`	`102`	`{`
`103`		`- Microsoft.VisualStudio.TestTools.UnitTesting.Assert.ThrowsException<Exception>(() => np.finfo(""));`
	`103`	`+ new Action(() => np.finfo("")).Should().Throw<Exception>();`
`104`	`104`	`}`
`105`	`105`
`106`	`106`	`[TestMethod]`
`107`	`107`	`public async Task FInfo_InvalidDtypeString_Throws()`
`108`	`108`	`{`
`109`		`- Microsoft.VisualStudio.TestTools.UnitTesting.Assert.ThrowsException<Exception>(() => np.finfo("int32"));`
	`109`	`+ new Action(() => np.finfo("int32")).Should().Throw<Exception>();`
`110`	`110`	`}`
`111`	`111`
`112`	`112`	`#endregion`
`@@ -139,7 +139,7 @@ public async Task FInfo_Generic_Decimal()`
`139`	`139`	`[TestMethod]`
`140`	`140`	`public async Task FInfo_Generic_Int_Throws()`
`141`	`141`	`{`
`142`		`- Microsoft.VisualStudio.TestTools.UnitTesting.Assert.ThrowsException<Exception>(() => np.finfo<int>());`
	`142`	`+ new Action(() => np.finfo<int>()).Should().Throw<Exception>();`
`143`	`143`	`}`
`144`	`144`
`145`	`145`	`#endregion`
`@@ -166,7 +166,7 @@ public async Task FInfo_NDArray_Float64()`
`166`	`166`	`public async Task FInfo_NDArray_Int_Throws()`
`167`	`167`	`{`
`168`	`168`	`var arr = np.array(new int[] { 1, 2, 3 });`
`169`		`- Microsoft.VisualStudio.TestTools.UnitTesting.Assert.ThrowsException<Exception>(() => np.finfo(arr));`
	`169`	`+ new Action(() => np.finfo(arr)).Should().Throw<Exception>();`
`170`	`170`	`}`
`171`	`171`
`172`	`172`	`#endregion`
Original file line number	Diff line number	Diff line change
`@@ -112,49 +112,49 @@ public async Task IInfo_Char_AllProperties()`
`112`	`112`	`[TestMethod]`
`113`	`113`	`public async Task IInfo_Single_Throws()`
`114`	`114`	`{`
`115`		`- Microsoft.VisualStudio.TestTools.UnitTesting.Assert.ThrowsException<Exception>(() => np.iinfo(NPTypeCode.Single));`
	`115`	`+ new Action(() => np.iinfo(NPTypeCode.Single)).Should().Throw<Exception>();`
`116`	`116`	`}`
`117`	`117`
`118`	`118`	`[TestMethod]`
`119`	`119`	`public async Task IInfo_Double_Throws()`
`120`	`120`	`{`
`121`		`- Microsoft.VisualStudio.TestTools.UnitTesting.Assert.ThrowsException<Exception>(() => np.iinfo(NPTypeCode.Double));`
	`121`	`+ new Action(() => np.iinfo(NPTypeCode.Double)).Should().Throw<Exception>();`
`122`	`122`	`}`
`123`	`123`
`124`	`124`	`[TestMethod]`
`125`	`125`	`public async Task IInfo_Decimal_Throws()`
`126`	`126`	`{`
`127`		`- Microsoft.VisualStudio.TestTools.UnitTesting.Assert.ThrowsException<Exception>(() => np.iinfo(NPTypeCode.Decimal));`
	`127`	`+ new Action(() => np.iinfo(NPTypeCode.Decimal)).Should().Throw<Exception>();`
`128`	`128`	`}`
`129`	`129`
`130`	`130`	`[TestMethod]`
`131`	`131`	`public async Task IInfo_Empty_Throws()`
`132`	`132`	`{`
`133`		`- Microsoft.VisualStudio.TestTools.UnitTesting.Assert.ThrowsException<Exception>(() => np.iinfo(NPTypeCode.Empty));`
	`133`	`+ new Action(() => np.iinfo(NPTypeCode.Empty)).Should().Throw<Exception>();`
`134`	`134`	`}`
`135`	`135`
`136`	`136`	`[TestMethod]`
`137`	`137`	`public async Task IInfo_NullType_Throws()`
`138`	`138`	`{`
`139`		`- Microsoft.VisualStudio.TestTools.UnitTesting.Assert.ThrowsException<Exception>(() => np.iinfo((Type)null!));`
	`139`	`+ new Action(() => np.iinfo((Type)null!)).Should().Throw<Exception>();`
`140`	`140`	`}`
`141`	`141`
`142`	`142`	`[TestMethod]`
`143`	`143`	`public async Task IInfo_NullArray_Throws()`
`144`	`144`	`{`
`145`		`- Microsoft.VisualStudio.TestTools.UnitTesting.Assert.ThrowsException<Exception>(() => np.iinfo((NDArray)null!));`
	`145`	`+ new Action(() => np.iinfo((NDArray)null!)).Should().Throw<Exception>();`
`146`	`146`	`}`
`147`	`147`
`148`	`148`	`[TestMethod]`
`149`	`149`	`public async Task IInfo_EmptyDtypeString_Throws()`
`150`	`150`	`{`
`151`		`- Microsoft.VisualStudio.TestTools.UnitTesting.Assert.ThrowsException<Exception>(() => np.iinfo(""));`
	`151`	`+ new Action(() => np.iinfo("")).Should().Throw<Exception>();`
`152`	`152`	`}`
`153`	`153`
`154`	`154`	`[TestMethod]`
`155`	`155`	`public async Task IInfo_InvalidDtypeString_Throws()`
`156`	`156`	`{`
`157`		`- Microsoft.VisualStudio.TestTools.UnitTesting.Assert.ThrowsException<Exception>(() => np.iinfo("float32"));`
	`157`	`+ new Action(() => np.iinfo("float32")).Should().Throw<Exception>();`
`158`	`158`	`}`
`159`	`159`
`160`	`160`	`#endregion`
`@@ -196,7 +196,7 @@ public async Task IInfo_Generic_Bool()`
`196`	`196`	`[TestMethod]`
`197`	`197`	`public async Task IInfo_Generic_Float_Throws()`
`198`	`198`	`{`
`199`		`- Microsoft.VisualStudio.TestTools.UnitTesting.Assert.ThrowsException<Exception>(() => np.iinfo<float>());`
	`199`	`+ new Action(() => np.iinfo<float>()).Should().Throw<Exception>();`
`200`	`200`	`}`
`201`	`201`
`202`	`202`	`#endregion`
`@@ -224,7 +224,7 @@ public async Task IInfo_NDArray_Byte()`
`224`	`224`	`public async Task IInfo_NDArray_Float_Throws()`
`225`	`225`	`{`
`226`	`226`	`var arr = np.array(new float[] { 1.0f, 2.0f });`
`227`		`- Microsoft.VisualStudio.TestTools.UnitTesting.Assert.ThrowsException<Exception>(() => np.iinfo(arr));`
	`227`	`+ new Action(() => np.iinfo(arr)).Should().Throw<Exception>();`
`228`	`228`	`}`
`229`	`229`
`230`	`230`	`#endregion`
Original file line number	Diff line number	Diff line change
`@@ -48,7 +48,7 @@ public async Task IsReal_ShapeMatches()`
`48`	`48`	`[TestMethod]`
`49`	`49`	`public async Task IsReal_Null_Throws()`
`50`	`50`	`{`
`51`		`- Microsoft.VisualStudio.TestTools.UnitTesting.Assert.ThrowsException<Exception>(() => np.isreal(null!));`
	`51`	`+ new Action(() => np.isreal(null!)).Should().Throw<Exception>();`
`52`	`52`	`}`
`53`	`53`
`54`	`54`	`#endregion`
`@@ -84,7 +84,7 @@ public async Task IsComplex_ShapeMatches()`
`84`	`84`	`[TestMethod]`
`85`	`85`	`public async Task IsComplex_Null_Throws()`
`86`	`86`	`{`
`87`		`- Microsoft.VisualStudio.TestTools.UnitTesting.Assert.ThrowsException<Exception>(() => np.iscomplex(null!));`
	`87`	`+ new Action(() => np.iscomplex(null!)).Should().Throw<Exception>();`
`88`	`88`	`}`
`89`	`89`
`90`	`90`	`#endregion`
`@@ -125,7 +125,7 @@ public async Task IsRealObj_AllTypes_True()`
`125`	`125`	`[TestMethod]`
`126`	`126`	`public async Task IsRealObj_Null_Throws()`
`127`	`127`	`{`
`128`		`- Microsoft.VisualStudio.TestTools.UnitTesting.Assert.ThrowsException<Exception>(() => np.isrealobj(null!));`
	`128`	`+ new Action(() => np.isrealobj(null!)).Should().Throw<Exception>();`
`129`	`129`	`}`
`130`	`130`
`131`	`131`	`#endregion`
`@@ -158,7 +158,7 @@ public async Task IsComplexObj_AllRealTypes_False()`
`158`	`158`	`[TestMethod]`
`159`	`159`	`public async Task IsComplexObj_Null_Throws()`
`160`	`160`	`{`
`161`		`- Microsoft.VisualStudio.TestTools.UnitTesting.Assert.ThrowsException<Exception>(() => np.iscomplexobj(null!));`
	`161`	`+ new Action(() => np.iscomplexobj(null!)).Should().Throw<Exception>();`
`162`	`162`	`}`
`163`	`163`
`164`	`164`	`#endregion`
Original file line number	Diff line number	Diff line change
`@@ -123,7 +123,7 @@ public async Task IsSubdtype_NDArray_String()`
`123`	`123`	`[TestMethod]`
`124`	`124`	`public async Task IsSubdtype_NDArray_Null_Throws()`
`125`	`125`	`{`
`126`		`- Microsoft.VisualStudio.TestTools.UnitTesting.Assert.ThrowsException<Exception>(() => np.issubdtype((NDArray)null!, "integer"));`
	`126`	`+ new Action(() => np.issubdtype((NDArray)null!, "integer")).Should().Throw<Exception>();`
`127`	`127`	`}`
`128`	`128`
`129`	`129`	`#endregion`
Original file line number	Diff line number	Diff line change
`@@ -136,7 +136,7 @@ public async Task MinScalarType_Decimal()`
`136`	`136`	`[TestMethod]`
`137`	`137`	`public async Task MinScalarType_Null_Throws()`
`138`	`138`	`{`
`139`		`- Microsoft.VisualStudio.TestTools.UnitTesting.Assert.ThrowsException<Exception>(() => np.min_scalar_type(null!));`
	`139`	`+ new Action(() => np.min_scalar_type(null!)).Should().Throw<Exception>();`
`140`	`140`	`}`
`141`	`141`
`142`	`142`	`#endregion`
Original file line number	Diff line number	Diff line change
`@@ -58,13 +58,13 @@ public async Task ResultType_Float32Float64_ReturnsFloat64()`
`58`	`58`	`[TestMethod]`
`59`	`59`	`public async Task ResultType_Empty_Throws()`
`60`	`60`	`{`
`61`		`- Microsoft.VisualStudio.TestTools.UnitTesting.Assert.ThrowsException<Exception>(() => np.result_type(Array.Empty<NPTypeCode>()));`
	`61`	`+ new Action(() => np.result_type(Array.Empty<NPTypeCode>())).Should().Throw<Exception>();`
`62`	`62`	`}`
`63`	`63`
`64`	`64`	`[TestMethod]`
`65`	`65`	`public async Task ResultType_NullArray_Throws()`
`66`	`66`	`{`
`67`		`- Microsoft.VisualStudio.TestTools.UnitTesting.Assert.ThrowsException<Exception>(() => np.result_type((NPTypeCode[])null!));`
	`67`	`+ new Action(() => np.result_type((NPTypeCode[])null!)).Should().Throw<Exception>();`
`68`	`68`	`}`
`69`	`69`
`70`	`70`	`#endregion`
`@@ -95,14 +95,14 @@ public async Task ResultType_TwoArg_NDArray()`
`95`	`95`	`public async Task ResultType_TwoArg_NDArray_NullFirst_Throws()`
`96`	`96`	`{`
`97`	`97`	`var b = np.array(new int[] { 1, 2 });`
`98`		`- Microsoft.VisualStudio.TestTools.UnitTesting.Assert.ThrowsException<Exception>(() => np.result_type((NDArray)null!, b));`
	`98`	`+ new Action(() => np.result_type((NDArray)null!, b)).Should().Throw<Exception>();`
`99`	`99`	`}`
`100`	`100`
`101`	`101`	`[TestMethod]`
`102`	`102`	`public async Task ResultType_TwoArg_NDArray_NullSecond_Throws()`
`103`	`103`	`{`
`104`	`104`	`var a = np.array(new int[] { 1, 2 });`
`105`		`- Microsoft.VisualStudio.TestTools.UnitTesting.Assert.ThrowsException<Exception>(() => np.result_type(a, (NDArray)null!));`
	`105`	`+ new Action(() => np.result_type(a, (NDArray)null!)).Should().Throw<Exception>();`
`106`	`106`	`}`
`107`	`107`
`108`	`108`	`#endregion`
Original file line number	Diff line number	Diff line change
`@@ -113,7 +113,7 @@ public async Task IsDtype_NDArray_Integral()`
`113`	`113`	`[TestMethod]`
`114`	`114`	`public async Task IsDtype_NDArray_Null_Throws()`
`115`	`115`	`{`
`116`		`- Microsoft.VisualStudio.TestTools.UnitTesting.Assert.ThrowsException<Exception>(() => np.isdtype((NDArray)null!, "integral"));`
	`116`	`+ new Action(() => np.isdtype((NDArray)null!, "integral")).Should().Throw<Exception>();`
`117`	`117`	`}`
`118`	`118`
`119`	`119`	`#endregion`
Original file line number	Diff line number	Diff line change
`@@ -94,7 +94,7 @@ public void EqualityComparer()`
`94`	`94`
`95`	`95`
`96`	`96`	`[TestMethod, Timeout(10000)]`
`97`		`- public void ExtractShape_FromArray(CancellationToken cancellationToken)`
	`97`	`+ public void ExtractShape_FromArray()`
`98`	`98`	`{`
`99`	`99`	`// @formatter:off — disable formatter after this line`
`100`	`100`	`var v = Shape.ExtractShape((Array)new int[][][]`