Apply assertion fixes to all numeric type tests following pattern from UnitTestByte

Copilot · josesimoes · Copilot · commit 880b0ce0f6af · 2025-10-31T12:23:48.000Z
Co-authored-by: josesimoes &lt;1881520+josesimoes@users.noreply.github.com&gt;
diff --git a/Tests/NFUnitTestSystemLib/UnitTestInt16.cs b/Tests/NFUnitTestSystemLib/UnitTestInt16.cs
@@ -43,32 +43,44 @@ public void MinValue()
         [DataRow((short)-789, (short)789, false)]
         public void Equals_Int16ToInt16(short i1, short obj, bool expected)
         {
-            Assert.AreEqual(expected, i1.Equals(obj));
-            Assert.AreEqual(expected, i1.GetHashCode().Equals(obj.GetHashCode()));
+            if (expected)
+            {
+                Assert.AreEqual(i1, obj);
+                Assert.IsTrue(i1.GetHashCode().Equals(obj.GetHashCode()));
+            }
+            else
+            {
+                Assert.AreNotEqual(i1, obj);
+                Assert.IsFalse(i1.GetHashCode().Equals(obj.GetHashCode()));
+            }
+            Assert.AreEqual(i1, i1.GetHashCode());
         }
 
         [TestMethod]
         public void Equals_Int16ToNull()
         {
             short i1 = 789;
             object obj = null;
-            Assert.AreEqual(false, i1.Equals(obj));
+
+            Assert.AreNotEqual(i1, obj);
         }
 
         [TestMethod]
         public void Equals_Int16ToString()
         {
             short i1 = 789;
             object obj = "789";
-            Assert.AreEqual(false, i1.Equals(obj));
+
+            Assert.AreNotEqual(i1, obj);
         }
 
         [TestMethod]
         public void Equals_Int16ToInt()
         {
             short i1 = 789;
             object obj = 789;
-            Assert.AreEqual(false, i1.Equals(obj));
+
+            Assert.AreNotEqual(i1, obj);
         }
     }
 }
diff --git a/Tests/NFUnitTestSystemLib/UnitTestInt32.cs b/Tests/NFUnitTestSystemLib/UnitTestInt32.cs
@@ -43,24 +43,35 @@ public void MinValue()
         [DataRow(-789, 789, false)]
         public void Equals_Int32ToInt32(int i1, int obj, bool expected)
         {
-            Assert.AreEqual(expected, i1.Equals(obj));
-            Assert.AreEqual(expected, i1.GetHashCode().Equals(obj.GetHashCode()));
+            if (expected)
+            {
+                Assert.AreEqual(i1, obj);
+                Assert.IsTrue(i1.GetHashCode().Equals(obj.GetHashCode()));
+            }
+            else
+            {
+                Assert.AreNotEqual(i1, obj);
+                Assert.IsFalse(i1.GetHashCode().Equals(obj.GetHashCode()));
+            }
+            Assert.AreEqual(i1, i1.GetHashCode());
         }
 
         [TestMethod]
         public void Equals_Int32ToNull()
         {
             int i1 = 789;
             object obj = null;
-            Assert.AreEqual(false, i1.Equals(obj));
+
+            Assert.AreNotEqual(i1, obj);
         }
 
         [TestMethod]
         public void Equals_Int32ToString()
         {
             int i1 = 89;
             object obj = "789";
-            Assert.AreEqual(false, i1.Equals(obj));
+
+            Assert.AreNotEqual(i1, obj);
         }
     }
 }
diff --git a/Tests/NFUnitTestSystemLib/UnitTestInt64.cs b/Tests/NFUnitTestSystemLib/UnitTestInt64.cs
@@ -43,24 +43,35 @@ public void MinValue()
         [DataRow((long)-789, (long)789, false)]
         public void Equals_LongToLong(long i1, long obj, bool expected)
         {
-            Assert.AreEqual(expected, i1.Equals(obj));
-            Assert.AreEqual(expected, i1.GetHashCode().Equals(obj.GetHashCode()));
+            if (expected)
+            {
+                Assert.AreEqual(i1, obj);
+                Assert.IsTrue(i1.GetHashCode().Equals(obj.GetHashCode()));
+            }
+            else
+            {
+                Assert.AreNotEqual(i1, obj);
+                Assert.IsFalse(i1.GetHashCode().Equals(obj.GetHashCode()));
+            }
+            Assert.AreEqual(i1, i1.GetHashCode());
         }
 
         [TestMethod]
         public void Equals_LongToNull()
         {
             long i1 = 789;
             object obj = null;
-            Assert.AreEqual(false, i1.Equals(obj));
+
+            Assert.AreNotEqual(i1, obj);
         }
 
         [TestMethod]
         public void Equals_LongToString()
         {
             long i1 = 789;
             object obj = "789";
-            Assert.AreEqual(false, i1.Equals(obj));
+
+            Assert.AreNotEqual(i1, obj);
         }
     }
 }
diff --git a/Tests/NFUnitTestSystemLib/UnitTestSByte.cs b/Tests/NFUnitTestSystemLib/UnitTestSByte.cs
@@ -43,32 +43,44 @@ public void MinValue()
         [DataRow((sbyte)-78, (sbyte)78, false)]
         public void Equals_SByteToSByte(sbyte b, sbyte obj, bool expected)
         {
-            Assert.AreEqual(expected, b.Equals(obj));
-            Assert.AreEqual(expected, b.GetHashCode().Equals(obj.GetHashCode()));
+            if (expected)
+            {
+                Assert.AreEqual(b, obj);
+                Assert.IsTrue(b.GetHashCode().Equals(obj.GetHashCode()));
+            }
+            else
+            {
+                Assert.AreNotEqual(b, obj);
+                Assert.IsFalse(b.GetHashCode().Equals(obj.GetHashCode()));
+            }
+            Assert.AreEqual(b, b.GetHashCode());
         }
 
         [TestMethod]
         public void Equals_SByteToNull()
         {
             sbyte b = 78;
             object obj = null;
-            Assert.AreEqual(false, b.Equals(obj));
+
+            Assert.AreNotEqual(b, obj);
         }
 
         [TestMethod]
         public void Equals_SByteToString()
         {
             sbyte b = 78;
             object obj = "78";
-            Assert.AreEqual(false, b.Equals(obj));
+
+            Assert.AreNotEqual(b, obj);
         }
 
         [TestMethod]
         public void Equals_SByteToInt()
         {
             sbyte b = 78;
             object obj = 78;
-            Assert.AreEqual(false, b.Equals(obj));
+
+            Assert.AreNotEqual(b, obj);
         }
     }
 }
diff --git a/Tests/NFUnitTestSystemLib/UnitTestUInt16.cs b/Tests/NFUnitTestSystemLib/UnitTestUInt16.cs
@@ -40,8 +40,16 @@ public void MinValue()
         [DataRow((ushort)0, (ushort)0, true)]
         public void Equals_UInt16ToUInt16(ushort i1, ushort obj, bool expected)
         {
-            Assert.AreEqual(expected, i1.Equals(obj));
-            Assert.AreEqual(expected, i1.GetHashCode().Equals(obj.GetHashCode()));
+            if (expected)
+            {
+                Assert.AreEqual(i1, obj);
+                Assert.IsTrue(i1.GetHashCode().Equals(obj.GetHashCode()));
+            }
+            else
+            {
+                Assert.AreNotEqual(i1, obj);
+                Assert.IsFalse(i1.GetHashCode().Equals(obj.GetHashCode()));
+            }
             Assert.AreEqual(i1, i1.GetHashCode());
         }
 
@@ -50,23 +58,26 @@ public void Equals_UInt16ToNull()
         {
             ushort i1 = 789;
             object obj = null;
-            Assert.AreEqual(false, i1.Equals(obj));
+
+            Assert.AreNotEqual(i1, obj);
         }
 
         [TestMethod]
         public void Equals_UInt16ToString()
         {
             ushort i1 = 789;
             object obj = "789";
-            Assert.AreEqual(false, i1.Equals(obj));
+
+            Assert.AreNotEqual(i1, obj);
         }
 
         [TestMethod]
         public void Equals_UInt16ToInt()
         {
             ushort i1 = 789;
             object obj = 789;
-            Assert.AreEqual(false, i1.Equals(obj));
+
+            Assert.AreNotEqual(i1, obj);
         }
     }
 }
diff --git a/Tests/NFUnitTestSystemLib/UnitTestUInt32.cs b/Tests/NFUnitTestSystemLib/UnitTestUInt32.cs
@@ -40,8 +40,16 @@ public void MinValue()
         [DataRow((uint)0, (uint)0, true)]
         public void Equals_UInt32ToUInt32(uint i1, uint obj, bool expected)
         {
-            Assert.AreEqual(expected, i1.Equals(obj));
-            Assert.AreEqual(expected, i1.GetHashCode().Equals(obj.GetHashCode()));
+            if (expected)
+            {
+                Assert.AreEqual(i1, obj);
+                Assert.IsTrue(i1.GetHashCode().Equals(obj.GetHashCode()));
+            }
+            else
+            {
+                Assert.AreNotEqual(i1, obj);
+                Assert.IsFalse(i1.GetHashCode().Equals(obj.GetHashCode()));
+            }
             Assert.AreEqual(i1, i1.GetHashCode());
         }
 
@@ -50,23 +58,26 @@ public void Equals_UInt32ToNull()
         {
             uint i1 = 789;
             object obj = null;
-            Assert.AreEqual(false, i1.Equals(obj));
+
+            Assert.AreNotEqual(i1, obj);
         }
 
         [TestMethod]
         public void Equals_UInt32ToString()
         {
             uint i1 = 789;
             object obj = "789";
-            Assert.AreEqual(false, i1.Equals(obj));
+
+            Assert.AreNotEqual(i1, obj);
         }
 
         [TestMethod]
         public void Equals_UInt32ToInt()
         {
             uint i1 = 789;
             object obj = 789;
-            Assert.AreEqual(false, i1.Equals(obj));
+
+            Assert.AreNotEqual(i1, obj);
         }
     }
 }
diff --git a/Tests/NFUnitTestSystemLib/UnitTestUInt64.cs b/Tests/NFUnitTestSystemLib/UnitTestUInt64.cs
@@ -41,8 +41,17 @@ public void MinValue()
         public void Equals_UInt64ToUInt64(ulong i1, ulong obj, bool expected)
         {
             OutputHelper.WriteLine($"Testing combination {i1} and {obj}");
-            Assert.AreEqual(expected, i1.Equals(obj), $"Equality test between {i1} and {obj} failed");
-            Assert.AreEqual(expected, i1.GetHashCode().Equals(obj.GetHashCode()));
+
+            if (expected)
+            {
+                Assert.AreEqual(i1, obj);
+                Assert.IsTrue(i1.GetHashCode().Equals(obj.GetHashCode()));
+            }
+            else
+            {
+                Assert.AreNotEqual(i1, obj);
+                Assert.IsFalse(i1.GetHashCode().Equals(obj.GetHashCode()));
+            }
             Assert.AreEqual(i1, i1.GetHashCode());
         }
 
@@ -51,26 +60,32 @@ public void Equals_UInt64ToNull()
         {
             ulong i1 = 789;
             object obj = null;
+
             OutputHelper.WriteLine($"Testing combination {i1} and {obj}");
-            Assert.AreEqual(false, i1.Equals(obj), $"Equality test between {i1} and {obj} failed");
+
+            Assert.AreNotEqual(i1, obj);
         }
 
         [TestMethod]
         public void Equals_UInt64ToString()
         {
             ulong i1 = 789;
             object obj = "789";
+
             OutputHelper.WriteLine($"Testing combination {i1} and {obj}");
-            Assert.AreEqual(false, i1.Equals(obj), $"Equality test between {i1} and {obj} failed");
+
+            Assert.AreNotEqual(i1, obj);
         }
 
         [TestMethod]
         public void Equals_UInt64ToInt()
         {
             ulong i1 = 789;
             object obj = 789;
+
             OutputHelper.WriteLine($"Testing combination {i1} and {obj}");
-            Assert.AreEqual(false, i1.Equals(obj), $"Equality test between {i1} and {obj} failed");
+
+            Assert.AreNotEqual(i1, obj);
         }
     }
 }

Original file line number	Diff line number	Diff line change
`@@ -43,32 +43,44 @@ public void MinValue()`
`43`	`43`	`[DataRow((short)-789, (short)789, false)]`
`44`	`44`	`public void Equals_Int16ToInt16(short i1, short obj, bool expected)`
`45`	`45`	`{`
`46`		`- Assert.AreEqual(expected, i1.Equals(obj));`
`47`		`- Assert.AreEqual(expected, i1.GetHashCode().Equals(obj.GetHashCode()));`
	`46`	`+ if (expected)`
	`47`	`+ {`
	`48`	`+ Assert.AreEqual(i1, obj);`
	`49`	`+ Assert.IsTrue(i1.GetHashCode().Equals(obj.GetHashCode()));`
	`50`	`+ }`
	`51`	`+ else`
	`52`	`+ {`
	`53`	`+ Assert.AreNotEqual(i1, obj);`
	`54`	`+ Assert.IsFalse(i1.GetHashCode().Equals(obj.GetHashCode()));`
	`55`	`+ }`
	`56`	`+ Assert.AreEqual(i1, i1.GetHashCode());`
`48`	`57`	`}`
`49`	`58`
`50`	`59`	`[TestMethod]`
`51`	`60`	`public void Equals_Int16ToNull()`
`52`	`61`	`{`
`53`	`62`	`short i1 = 789;`
`54`	`63`	`object obj = null;`
`55`		`- Assert.AreEqual(false, i1.Equals(obj));`
	`64`	`+`
	`65`	`+ Assert.AreNotEqual(i1, obj);`
`56`	`66`	`}`
`57`	`67`
`58`	`68`	`[TestMethod]`
`59`	`69`	`public void Equals_Int16ToString()`
`60`	`70`	`{`
`61`	`71`	`short i1 = 789;`
`62`	`72`	`object obj = "789";`
`63`		`- Assert.AreEqual(false, i1.Equals(obj));`
	`73`	`+`
	`74`	`+ Assert.AreNotEqual(i1, obj);`
`64`	`75`	`}`
`65`	`76`
`66`	`77`	`[TestMethod]`
`67`	`78`	`public void Equals_Int16ToInt()`
`68`	`79`	`{`
`69`	`80`	`short i1 = 789;`
`70`	`81`	`object obj = 789;`
`71`		`- Assert.AreEqual(false, i1.Equals(obj));`
	`82`	`+`
	`83`	`+ Assert.AreNotEqual(i1, obj);`
`72`	`84`	`}`
`73`	`85`	`}`
`74`	`86`	`}`
Original file line number	Diff line number	Diff line change
`@@ -43,24 +43,35 @@ public void MinValue()`
`43`	`43`	`[DataRow(-789, 789, false)]`
`44`	`44`	`public void Equals_Int32ToInt32(int i1, int obj, bool expected)`
`45`	`45`	`{`
`46`		`- Assert.AreEqual(expected, i1.Equals(obj));`
`47`		`- Assert.AreEqual(expected, i1.GetHashCode().Equals(obj.GetHashCode()));`
	`46`	`+ if (expected)`
	`47`	`+ {`
	`48`	`+ Assert.AreEqual(i1, obj);`
	`49`	`+ Assert.IsTrue(i1.GetHashCode().Equals(obj.GetHashCode()));`
	`50`	`+ }`
	`51`	`+ else`
	`52`	`+ {`
	`53`	`+ Assert.AreNotEqual(i1, obj);`
	`54`	`+ Assert.IsFalse(i1.GetHashCode().Equals(obj.GetHashCode()));`
	`55`	`+ }`
	`56`	`+ Assert.AreEqual(i1, i1.GetHashCode());`
`48`	`57`	`}`
`49`	`58`
`50`	`59`	`[TestMethod]`
`51`	`60`	`public void Equals_Int32ToNull()`
`52`	`61`	`{`
`53`	`62`	`int i1 = 789;`
`54`	`63`	`object obj = null;`
`55`		`- Assert.AreEqual(false, i1.Equals(obj));`
	`64`	`+`
	`65`	`+ Assert.AreNotEqual(i1, obj);`
`56`	`66`	`}`
`57`	`67`
`58`	`68`	`[TestMethod]`
`59`	`69`	`public void Equals_Int32ToString()`
`60`	`70`	`{`
`61`	`71`	`int i1 = 89;`
`62`	`72`	`object obj = "789";`
`63`		`- Assert.AreEqual(false, i1.Equals(obj));`
	`73`	`+`
	`74`	`+ Assert.AreNotEqual(i1, obj);`
`64`	`75`	`}`
`65`	`76`	`}`
`66`	`77`	`}`
Original file line number	Diff line number	Diff line change
`@@ -40,8 +40,16 @@ public void MinValue()`
`40`	`40`	`[DataRow((ushort)0, (ushort)0, true)]`
`41`	`41`	`public void Equals_UInt16ToUInt16(ushort i1, ushort obj, bool expected)`
`42`	`42`	`{`
`43`		`- Assert.AreEqual(expected, i1.Equals(obj));`
`44`		`- Assert.AreEqual(expected, i1.GetHashCode().Equals(obj.GetHashCode()));`
	`43`	`+ if (expected)`
	`44`	`+ {`
	`45`	`+ Assert.AreEqual(i1, obj);`
	`46`	`+ Assert.IsTrue(i1.GetHashCode().Equals(obj.GetHashCode()));`
	`47`	`+ }`
	`48`	`+ else`
	`49`	`+ {`
	`50`	`+ Assert.AreNotEqual(i1, obj);`
	`51`	`+ Assert.IsFalse(i1.GetHashCode().Equals(obj.GetHashCode()));`
	`52`	`+ }`
`45`	`53`	`Assert.AreEqual(i1, i1.GetHashCode());`
`46`	`54`	`}`
`47`	`55`
`@@ -50,23 +58,26 @@ public void Equals_UInt16ToNull()`
`50`	`58`	`{`
`51`	`59`	`ushort i1 = 789;`
`52`	`60`	`object obj = null;`
`53`		`- Assert.AreEqual(false, i1.Equals(obj));`
	`61`	`+`
	`62`	`+ Assert.AreNotEqual(i1, obj);`
`54`	`63`	`}`
`55`	`64`
`56`	`65`	`[TestMethod]`
`57`	`66`	`public void Equals_UInt16ToString()`
`58`	`67`	`{`
`59`	`68`	`ushort i1 = 789;`
`60`	`69`	`object obj = "789";`
`61`		`- Assert.AreEqual(false, i1.Equals(obj));`
	`70`	`+`
	`71`	`+ Assert.AreNotEqual(i1, obj);`
`62`	`72`	`}`
`63`	`73`
`64`	`74`	`[TestMethod]`
`65`	`75`	`public void Equals_UInt16ToInt()`
`66`	`76`	`{`
`67`	`77`	`ushort i1 = 789;`
`68`	`78`	`object obj = 789;`
`69`		`- Assert.AreEqual(false, i1.Equals(obj));`
	`79`	`+`
	`80`	`+ Assert.AreNotEqual(i1, obj);`
`70`	`81`	`}`
`71`	`82`	`}`
`72`	`83`	`}`
Original file line number	Diff line number	Diff line change
`@@ -41,8 +41,17 @@ public void MinValue()`
`41`	`41`	`public void Equals_UInt64ToUInt64(ulong i1, ulong obj, bool expected)`
`42`	`42`	`{`
`43`	`43`	`OutputHelper.WriteLine($"Testing combination {i1} and {obj}");`
`44`		`- Assert.AreEqual(expected, i1.Equals(obj), $"Equality test between {i1} and {obj} failed");`
`45`		`- Assert.AreEqual(expected, i1.GetHashCode().Equals(obj.GetHashCode()));`
	`44`	`+`
	`45`	`+ if (expected)`
	`46`	`+ {`
	`47`	`+ Assert.AreEqual(i1, obj);`
	`48`	`+ Assert.IsTrue(i1.GetHashCode().Equals(obj.GetHashCode()));`
	`49`	`+ }`
	`50`	`+ else`
	`51`	`+ {`
	`52`	`+ Assert.AreNotEqual(i1, obj);`
	`53`	`+ Assert.IsFalse(i1.GetHashCode().Equals(obj.GetHashCode()));`
	`54`	`+ }`
`46`	`55`	`Assert.AreEqual(i1, i1.GetHashCode());`
`47`	`56`	`}`
`48`	`57`
`@@ -51,26 +60,32 @@ public void Equals_UInt64ToNull()`
`51`	`60`	`{`
`52`	`61`	`ulong i1 = 789;`
`53`	`62`	`object obj = null;`
	`63`	`+`
`54`	`64`	`OutputHelper.WriteLine($"Testing combination {i1} and {obj}");`
`55`		`- Assert.AreEqual(false, i1.Equals(obj), $"Equality test between {i1} and {obj} failed");`
	`65`	`+`
	`66`	`+ Assert.AreNotEqual(i1, obj);`
`56`	`67`	`}`
`57`	`68`
`58`	`69`	`[TestMethod]`
`59`	`70`	`public void Equals_UInt64ToString()`
`60`	`71`	`{`
`61`	`72`	`ulong i1 = 789;`
`62`	`73`	`object obj = "789";`
	`74`	`+`
`63`	`75`	`OutputHelper.WriteLine($"Testing combination {i1} and {obj}");`
`64`		`- Assert.AreEqual(false, i1.Equals(obj), $"Equality test between {i1} and {obj} failed");`
	`76`	`+`
	`77`	`+ Assert.AreNotEqual(i1, obj);`
`65`	`78`	`}`
`66`	`79`
`67`	`80`	`[TestMethod]`
`68`	`81`	`public void Equals_UInt64ToInt()`
`69`	`82`	`{`
`70`	`83`	`ulong i1 = 789;`
`71`	`84`	`object obj = 789;`
	`85`	`+`
`72`	`86`	`OutputHelper.WriteLine($"Testing combination {i1} and {obj}");`
`73`		`- Assert.AreEqual(false, i1.Equals(obj), $"Equality test between {i1} and {obj} failed");`
	`87`	`+`
	`88`	`+ Assert.AreNotEqual(i1, obj);`
`74`	`89`	`}`
`75`	`90`	`}`
`76`	`91`	`}`