Lucene.Net.TestFramework: Added overloads for int to Assert.AreEqual …

…(addresses apache#295, apache#261)
bongohrtech · Jun 23, 2020 · 4af199b · 4af199b
1 parent a17936a
commit 4af199b
Show file tree

Hide file tree

Showing 4 changed files with 88 additions and 8 deletions.
diff --git a/src/Lucene.Net.TestFramework.NUnit/Support/TestFramework/Assert.cs b/src/Lucene.Net.TestFramework.NUnit/Support/TestFramework/Assert.cs
@@ -164,6 +164,45 @@ public static void AreEqual(double expected, double actual, double delta)
             _NUnit.Assert.AreEqual(expected, actual, delta);
         }
 
+        //
+        // Summary:
+        //     Verifies that two objects are equal. Two objects are considered equal if both
+        //     are null, or if both have the same value. NUnit has special semantics for some
+        //     object types. If they are not equal an NUnit.Framework.AssertionException is
+        //     thrown.
+        //
+        // Parameters:
+        //   expected:
+        //     The value that is expected
+        //
+        //   actual:
+        //     The actual value
+        public static void AreEqual(int expected, int actual)
+        {
+            _NUnit.Assert.True(expected.Equals(actual));
+        }
+
+        //
+        // Summary:
+        //     Verifies that two objects are equal. Two objects are considered equal if both
+        //     are null, or if both have the same value. NUnit has special semantics for some
+        //     object types. If they are not equal an NUnit.Framework.AssertionException is
+        //     thrown.
+        //
+        // Parameters:
+        //   expected:
+        //     The value that is expected
+        //
+        //   message:
+        //     The message to display in case of failure
+        //
+        //   actual:
+        //     The actual value
+        public static void AreEqual(int expected, int actual, string message)
+        {
+            _NUnit.Assert.True(expected.Equals(actual), message);
+        }
+
         //
         // Summary:
         //     Verifies that two objects are equal. Two objects are considered equal if both
@@ -179,7 +218,7 @@ public static void AreEqual(double expected, double actual, double delta)
         //     The actual value
         public static void AreEqual(long expected, long actual)
         {
-            _NUnit.Assert.True(expected == actual);
+            _NUnit.Assert.True(expected.Equals(actual));
         }
 
         //
@@ -200,7 +239,25 @@ public static void AreEqual(long expected, long actual)
         //     The actual value
         public static void AreEqual(long expected, long actual, string message)
         {
-            _NUnit.Assert.True(expected == actual, message);
+            _NUnit.Assert.True(expected.Equals(actual), message);
+        }
+
+        //
+        // Summary:
+        //     Verifies that two objects are equal. Two objects are considered equal if both
+        //     are null, or if both have the same value. NUnit has special semantics for some
+        //     object types. If they are not equal an NUnit.Framework.AssertionException is
+        //     thrown.
+        //
+        // Parameters:
+        //   expected:
+        //     The value that is expected
+        //
+        //   actual:
+        //     The actual value
+        public static void AreEqual(byte expected, byte actual)
+        {
+            _NUnit.Assert.True(expected.Equals(actual));
         }
 
         //
@@ -214,12 +271,15 @@ public static void AreEqual(long expected, long actual, string message)
         //   expected:
         //     The value that is expected
         //
+        //   message:
+        //     The message to display in case of failure
+        //
         //   actual:
         //     The actual value
-        //public static void AreEqual(byte expected, byte actual)
-        //{
-        //    _NUnit.Assert.True(expected == actual);
-        //}
+        public static void AreEqual(byte expected, byte actual, string message)
+        {
+            _NUnit.Assert.True(expected.Equals(actual), message);
+        }
 
         // From CollectionAssert
         public static void AreEqual<T>(T[] expected, T[] actual)

diff --git a/src/Lucene.Net.TestFramework/Index/BaseStoredFieldsFormatTestCase.cs b/src/Lucene.Net.TestFramework/Index/BaseStoredFieldsFormatTestCase.cs
@@ -266,7 +266,7 @@ public virtual void TestBinaryFieldOffsetLength()
                     b = f2.GetBinaryValue().Bytes;
                     Assert.IsTrue(b != null);
                     Assert.AreEqual(17, b.Length, 17);
-                    Assert.AreEqual(87, b[0]);
+                    Assert.AreEqual((byte)87, b[0]);
                 } // ir.Dispose();
             } // dir.Dispose();
         }

diff --git a/src/Lucene.Net.TestFramework/Support/JavaCompatibility/LuceneTestCase.cs b/src/Lucene.Net.TestFramework/Support/JavaCompatibility/LuceneTestCase.cs
@@ -102,6 +102,26 @@ internal static void assertEquals(string message, long expected, long actual)
             //Assert.AreEqual(expected, actual, message);
         }
 
+        internal static void assertEquals(int expected, int actual)
+        {
+            Assert.AreEqual(expected, actual);
+        }
+
+        internal static void assertEquals(string message, int expected, int actual)
+        {
+            Assert.AreEqual(expected, actual, message);
+        }
+
+        internal static void assertEquals(byte expected, byte actual)
+        {
+            Assert.AreEqual(expected, actual);
+        }
+
+        internal static void assertEquals(string message, byte expected, byte actual)
+        {
+            Assert.AreEqual(expected, actual, message);
+        }
+
         internal static void assertEquals<T>(ISet<T> expected, ISet<T> actual)
         {
             Assert.True(JCG.SetEqualityComparer<T>.Default.Equals(expected, actual));

diff --git a/src/Lucene.Net.Tests/Util/Fst/TestFSTs.cs b/src/Lucene.Net.Tests/Util/Fst/TestFSTs.cs
@@ -1882,7 +1882,7 @@ public virtual void TestLargeOutputsOnArrayArcs()
                 Assert.AreEqual(result.Bytes[result.Offset], arc);
                 for (int byteIDX = 1; byteIDX < result.Length; byteIDX++)
                 {
-                    Assert.AreEqual(0, result.Bytes[result.Offset + byteIDX]);
+                    Assert.AreEqual((byte)0, result.Bytes[result.Offset + byteIDX]);
                 }
             }
         }