updated division tests

Author: AronDavis

FInt/FInt.cs

@@ -3,7 +3,7 @@ public struct FInt
     #region Constants
 
     public const int PRICISION = 6;
-	private const long _SCALE = 1000000;
+	private const long _SCALE = 1_000_000;
 
     #endregion
 
@@ -314,14 +314,14 @@ old method (so we can compare in tests)
 		return new FInt(whole * _SCALE + remainder, UseScale.None);
 	}
 
-	public static FInt operator / (FInt fi1, int i)
+	public static FInt operator / (FInt left, int right)
 	{
-		return new FInt(fi1._value / i, UseScale.None);
+		return new FInt(left._value / right, UseScale.None);
 	}
 
-	public static FInt operator / (FInt fi1, long lng)
+	public static FInt operator / (FInt left, long right)
 	{
-		return new FInt(fi1._value / lng, UseScale.None);
+		return new FInt(left._value / right, UseScale.None);
 	}
 
 	#endregion

Tests/DivisionTests.cs

@@ -1,16 +1,28 @@
 using Microsoft.VisualStudio.TestTools.UnitTesting;
+using System.Numerics;
 
 namespace Tests
 {
     [TestClass]
     public class DivisionTests
     {
+        [TestMethod]
+        public void DivisionByZero_ShouldThrowException()
+        {
+            Assert.ThrowsException<DivideByZeroException>(() => 1.FI() / 0.FI());
+            Assert.ThrowsException<DivideByZeroException>(() => 1.FI() / 0);
+            Assert.ThrowsException<DivideByZeroException>(() => 1.FI() / (long)0);
+        }
+
         [DataTestMethod]
+        [DataRow(0, 1, 0, 0)]
+        [DataRow(1, 1, 1, 0)]
+        [DataRow(4, 2, 2, 0)]
         [DataRow(1, 2, 0, 5)]
         [DataRow(1, 4, 0, 25)]
         [DataRow(3, 2, 1, 5)]
         [DataRow(7, 3, 2, 333333)]
-        public void DivisionWithNonIntegerQuotient_ShouldWorkAsExpected(int left, int right, int expectedWhole, int expectedDecimal)
+        public void DivisionByFInt_ShouldWorkAsExpected(int left, int right, int expectedWhole, int expectedDecimal)
         {
             void assertDivision(int l, int r, int ew, int ed)
             {
@@ -33,26 +45,6 @@ void assertDivision(int l, int r, int ew, int ed)
             assertDivision(-left, -right, expectedWhole, expectedDecimal);
         }
 
-        [DataTestMethod]
-        [DataRow(0, 1, 0)]
-        [DataRow(1, 1, 1)]
-        [DataRow(4, 2, 2)]
-        public void DivisionWithIntegerQuotient_ShouldWorkAsExpected(int left, int right, int expectedResult)
-        {
-            void assertDivision(int l, int r, int e)
-            {
-                FInt result = l.FI() / r.FI();
-                FInt expected = e;
-
-                Assert.AreEqual(expected, result);
-            }
-
-            assertDivision(left, right, expectedResult);
-            assertDivision(-left, right, -expectedResult);
-            assertDivision(left, -right, -expectedResult);
-            assertDivision(-left, -right, expectedResult);
-        }
-
         [DataTestMethod]
         [DataRow(1, 2, 1, 4, 2, 0)]
         [DataRow(2, 10, 3, 10, 0, 666666)]
@@ -82,10 +74,66 @@ void assertDivision(FInt l, FInt r, int ew, int ed)
             assertDivision(-numerator, -denominator, expectedWhole, expectedDecimal);
         }
 
-        [TestMethod]
-        public void DivisionByZero_ShouldThrowException()
+        [DataTestMethod]
+        [DataRow(0, 1, 0, 0)]
+        [DataRow(1, 1, 1, 0)]
+        [DataRow(4, 2, 2, 0)]
+        [DataRow(1, 2, 0, 5)]
+        [DataRow(1, 4, 0, 25)]
+        [DataRow(3, 2, 1, 5)]
+        [DataRow(7, 3, 2, 333333)]
+        public void DivisionByInt_ShouldWorkAsExpected(int left, int right, int expectedWhole, int expectedDecimal)
         {
-            Assert.ThrowsException<DivideByZeroException>(() => 1.FI() / 0.FI());
+            void assertDivision(int l, int r, int ew, int ed)
+            {
+                FInt result = l.FI() / r;
+
+                FInt shiftedDecimal = ed;
+
+                while (shiftedDecimal.Decimal != 0)
+                {
+                    shiftedDecimal *= 10;
+                }
+
+                Assert.AreEqual(ew.FI(), result.Sign * ((result.Sign * result) - result.Decimal));
+                Assert.AreEqual(ed.FI(), shiftedDecimal);
+            }
+
+            assertDivision(left, right, expectedWhole, expectedDecimal);
+            assertDivision(-left, right, -expectedWhole, expectedDecimal);
+            assertDivision(left, -right, -expectedWhole, expectedDecimal);
+            assertDivision(-left, -right, expectedWhole, expectedDecimal);
+        }
+
+        [DataTestMethod]
+        [DataRow(0, 1, 0, 0)]
+        [DataRow(1, 1, 1, 0)]
+        [DataRow(4, 2, 2, 0)]
+        [DataRow(1, 2, 0, 5)]
+        [DataRow(1, 4, 0, 25)]
+        [DataRow(3, 2, 1, 5)]
+        [DataRow(7, 3, 2, 333333)]
+        public void DivisionByLong_ShouldWorkAsExpected(int left, long right, int expectedWhole, int expectedDecimal)
+        {
+            void assertDivision(int l, long r, int ew, int ed)
+            {
+                FInt result = l.FI() / r;
+
+                FInt shiftedDecimal = ed;
+
+                while (shiftedDecimal.Decimal != 0)
+                {
+                    shiftedDecimal *= 10;
+                }
+
+                Assert.AreEqual(ew.FI(), result.Sign * ((result.Sign * result) - result.Decimal));
+                Assert.AreEqual(ed.FI(), shiftedDecimal);
+            }
+
+            assertDivision(left, right, expectedWhole, expectedDecimal);
+            assertDivision(-left, right, -expectedWhole, expectedDecimal);
+            assertDivision(left, -right, -expectedWhole, expectedDecimal);
+            assertDivision(-left, -right, expectedWhole, expectedDecimal);
         }
     }
 }