[Fix] Random Factory NextBigInteger

src/Neo.Extensions/BigIntegerExtensions.cs

@@ -156,12 +156,6 @@ public static BigInteger Sqrt(this BigInteger value)
             return z;
         }
 
-        internal static BigInteger GetLowPart(this BigInteger value, int bitCount)
-        {
-            var mask = (BigInteger.One << bitCount) - 1;
-            return value & mask;
-        }
-
         /// <summary>
         /// Gets the number of bits required for shortest two's complement representation of the current instance without the sign bit.
         /// Note: This method is imprecise and might not work as expected with integers larger than 256 bits if less than .NET5.

src/Neo.Extensions/Factories/RandomNumberFactory.cs

@@ -176,15 +176,15 @@ public static ulong NextUInt64()
 
         public static ulong NextUInt64(ulong maxValue)
         {
-            var randomProduct = BigMul(maxValue, NextUInt64(), out var lowPart);
+            var randomProduct = Math.BigMul(maxValue, NextUInt64(), out var lowPart);
 
             if (lowPart < maxValue)
             {
                 var remainder = (0ul - maxValue) % maxValue;
 
                 while (lowPart < remainder)
                 {
-                    randomProduct = BigMul(maxValue, NextUInt64(), out lowPart);
+                    randomProduct = Math.BigMul(maxValue, NextUInt64(), out lowPart);
                 }
             }
 
@@ -216,34 +216,27 @@ public static BigInteger NextBigInteger(BigInteger maxValue)
             if (maxValue.Sign < 0)
                 throw new ArgumentOutOfRangeException(nameof(maxValue));
 
+            if (maxValue == 0 || maxValue == 1)
+                return BigInteger.Zero;
+
             var maxValueBits = maxValue.GetByteCount() * 8;
-            var maxValueSize = BigInteger.Pow(2, maxValueBits);
+            var maxMaxValue = BigInteger.One << maxValueBits;
 
             var randomProduct = maxValue * NextBigInteger(maxValueBits);
-            var randomProductBits = randomProduct.GetByteCount() * 8;
-
-            var lowPart = randomProduct.GetLowPart(maxValueBits);
+            var lowPart = randomProduct % maxMaxValue;
 
             if (lowPart < maxValue)
             {
-                var remainder = (maxValueSize - maxValue) % maxValue;
+                var threshold = (maxMaxValue - maxValue) % maxValue;
 
-                while (lowPart < remainder)
+                while (lowPart < threshold)
                 {
                     randomProduct = maxValue * NextBigInteger(maxValueBits);
-                    randomProductBits = randomProduct.GetByteCount() * 8;
-                    lowPart = randomProduct.GetLowPart(maxValueBits);
+                    lowPart = randomProduct % maxMaxValue;
                 }
             }
 
-            var result = randomProduct >> (randomProductBits - maxValueBits);
-
-            // Since BigInteger doesn't have a max value or bit size
-            // anything over 'maxValue' return zero
-            if (result >= maxValue)
-                return BigInteger.Zero;
-
-            return result;
+            return randomProduct >> maxValueBits;
         }
 
         public static BigInteger NextBigInteger(int sizeInBits)
@@ -264,28 +257,5 @@ public static BigInteger NextBigInteger(int sizeInBits)
 
             return new BigInteger(b);
         }
-
-        private static ulong BigMul(ulong a, ulong b, out ulong low)
-        {
-            // Adaptation of algorithm for multiplication
-            // of 32-bit unsigned integers described
-            // in Hacker's Delight by Henry S. Warren, Jr. (ISBN 0-201-91465-4), Chapter 8
-            // Basically, it's an optimized version of FOIL method applied to
-            // low and high dwords of each operand
-
-            // Use 32-bit uints to optimize the fallback for 32-bit platforms.
-            var al = (uint)a;
-            var ah = (uint)(a >> 32);
-            var bl = (uint)b;
-            var bh = (uint)(b >> 32);
-
-            var mull = ((ulong)al) * bl;
-            var t = ((ulong)ah) * bl + (mull >> 32);
-            var tl = ((ulong)al) * bh + (uint)t;
-
-            low = (tl << 32) | (uint)mull;
-
-            return ((ulong)ah) * bh + (t >> 32) + (tl >> 32);
-        }
     }
 }

tests/Neo.Extensions.Tests/Factories/UT_RandomNumberFactory.cs

@@ -43,7 +43,7 @@ public void CheckNextSByteInRange()
             Assert.IsTrue(actualValue >= expectedMin && actualValue <= expectedMax);
 
             actualValue = RandomNumberFactory.NextSByte(expectedMax);
-            Assert.IsTrue(actualValue >= expectedMin && actualValue <= expectedMax);
+            Assert.IsTrue(actualValue >= 0 && actualValue <= expectedMax);
         }
 
         [TestMethod]
@@ -76,7 +76,7 @@ public void CheckNextByteInRange()
             Assert.IsTrue(actualValue >= expectedMin && actualValue <= expectedMax);
 
             actualValue = RandomNumberFactory.NextByte(expectedMax);
-            Assert.IsTrue(actualValue >= expectedMin && actualValue <= expectedMax);
+            Assert.IsTrue(actualValue >= 0 && actualValue <= expectedMax);
         }
 
         [TestMethod]
@@ -92,7 +92,7 @@ public void CheckNextInt16InRange()
             Assert.IsTrue(actualValue >= expectedMin && actualValue <= expectedMax);
 
             actualValue = RandomNumberFactory.NextInt16(expectedMax);
-            Assert.IsTrue(actualValue >= expectedMin && actualValue <= expectedMax);
+            Assert.IsTrue(actualValue >= 0 && actualValue <= expectedMax);
         }
 
         [TestMethod]
@@ -105,7 +105,7 @@ public void CheckNextInt16InNegative()
             Assert.IsTrue(actualValue >= expectedMin && actualValue <= expectedMax);
 
             actualValue = RandomNumberFactory.NextInt16(expectedMax);
-            Assert.IsTrue(actualValue >= expectedMin && actualValue <= expectedMax);
+            Assert.IsTrue(actualValue >= 0 && actualValue <= expectedMax);
         }
 
         [TestMethod]
@@ -128,7 +128,7 @@ public void CheckNextUInt16InRange()
             Assert.IsTrue(actualValue >= expectedMin && actualValue <= expectedMax);
 
             actualValue = RandomNumberFactory.NextUInt16(expectedMax);
-            Assert.IsTrue(actualValue >= expectedMin && actualValue <= expectedMax);
+            Assert.IsTrue(actualValue >= 0 && actualValue <= expectedMax);
         }
 
         [TestMethod]
@@ -144,7 +144,7 @@ public void CheckNextInt32InRange()
             Assert.IsTrue(actualValue >= expectedMin && actualValue <= expectedMax);
 
             actualValue = RandomNumberFactory.NextInt32(expectedMax);
-            Assert.IsTrue(actualValue >= expectedMin && actualValue <= expectedMax);
+            Assert.IsTrue(actualValue >= 0 && actualValue <= expectedMax);
         }
 
         [TestMethod]
@@ -177,7 +177,7 @@ public void CheckNextUInt32InRange()
             Assert.IsTrue(actualValue >= expectedMin && actualValue <= expectedMax);
 
             actualValue = RandomNumberFactory.NextUInt32(expectedMax);
-            Assert.IsTrue(actualValue >= expectedMin && actualValue <= expectedMax);
+            Assert.IsTrue(actualValue >= 0 && actualValue <= expectedMax);
         }
 
         [TestMethod]
@@ -193,7 +193,7 @@ public void CheckNextInt64InRange()
             Assert.IsTrue(actualValue >= expectedMin && actualValue <= expectedMax);
 
             actualValue = RandomNumberFactory.NextInt64(expectedMax);
-            Assert.IsTrue(actualValue >= expectedMin && actualValue <= expectedMax);
+            Assert.IsTrue(actualValue >= 0 && actualValue <= expectedMax);
         }
 
         [TestMethod]
@@ -226,7 +226,7 @@ public void CheckNextUInt64InRange()
             Assert.IsTrue(actualValue >= expectedMin && actualValue <= expectedMax);
 
             actualValue = RandomNumberFactory.NextUInt64(expectedMax);
-            Assert.IsTrue(actualValue >= expectedMin && actualValue <= expectedMax);
+            Assert.IsTrue(actualValue >= 0 && actualValue <= expectedMax);
         }
 
         [TestMethod]
@@ -245,7 +245,7 @@ public void CheckNextBigIntegerSizeInBits()
         public void CheckNextBigIntegerInRange()
         {
             var expectedMax = BigInteger.Pow(2, 100);
-            var expectedMin = BigInteger.Zero;
+            var expectedMin = BigInteger.Pow(2, 50);
 
             Assert.AreEqual(expectedMax, RandomNumberFactory.NextBigInteger(expectedMax, expectedMax));
             Assert.AreEqual(expectedMin, RandomNumberFactory.NextBigInteger(expectedMin, expectedMin));
@@ -254,7 +254,7 @@ public void CheckNextBigIntegerInRange()
             Assert.IsTrue(actualValue >= expectedMin && actualValue <= expectedMax);
 
             actualValue = RandomNumberFactory.NextBigInteger(expectedMax);
-            Assert.IsTrue(actualValue >= expectedMin && actualValue <= expectedMax);
+            Assert.IsTrue(actualValue >= 0 && actualValue <= expectedMax);
         }
 
         [TestMethod]
@@ -285,7 +285,20 @@ public void CheckNextBigIntegerSmallValues()
             Assert.IsTrue(actualValue >= expectedMin && actualValue <= expectedMax);
 
             actualValue = RandomNumberFactory.NextBigInteger(expectedMax);
+            Assert.IsTrue(actualValue >= 0 && actualValue <= expectedMax);
+        }
+
+        [TestMethod]
+        public void CheckNextBigIntegerZero()
+        {
+            var expectedMax = BigInteger.Zero;
+            var expectedMin = BigInteger.Zero;
+
+            var actualValue = RandomNumberFactory.NextBigInteger(expectedMin, expectedMax);
             Assert.IsTrue(actualValue >= expectedMin && actualValue <= expectedMax);
+
+            actualValue = RandomNumberFactory.NextBigInteger(expectedMax);
+            Assert.IsTrue(actualValue >= 0 && actualValue <= expectedMax);
         }
     }
 }