Refresh on Fermat prime checker and added new tests. (#99)

* Refresh on radix sorter and added new tests

* static methods mods

* Refresh on Fermat prime checker and added new tests.

Author: 1fisedi

Algorithms.Tests/Other/FermatPrimeCheckerTests.cs

@@ -0,0 +1,29 @@
+using Algorithms.Other;
+
+using NUnit.Framework;
+using NUnit.Framework.Internal;
+
+namespace Algorithms.Tests.Other
+{
+    public static class FermatPrimeCheckerTests
+    {
+        [Test]
+        [TestCase(5, true)]
+        [TestCase(2633, true)]
+        [TestCase(9439, true)]
+        [TestCase(1, false)]
+        [TestCase(8, false)]
+        public static void IsProbablePrime(int inputNum, bool expected)
+        {
+            // Arrange
+            var random = new Randomizer();
+            var times = random.Next(1, 1000);
+
+            // Act
+            var result = FermatPrimeChecker.IsPrime(inputNum, times);
+
+            // Assert
+            Assert.AreEqual(expected, result);
+        }
+    }
+}

Algorithms.Tests/Sorters/BucketSorterTests.cs

@@ -7,10 +7,10 @@
 
 namespace Algorithms.Tests.Sorters
 {
-    public class BucketSorterTests
+    public static class BucketSorterTests
     {
         [Test]
-        public void ArraySorted([Random(0, 1000, 100, Distinct = true)]int n)
+        public static void ArraySorted([Random(0, 1000, 1000, Distinct = true)]int n)
         {
             // Arrange
             var sorter = new BucketSorter();

Algorithms.Tests/Sorters/RadixSorterTests.cs

@@ -0,0 +1,27 @@
+using System;
+
+using Algorithms.Sorters;
+using Algorithms.Tests.Helpers;
+
+using NUnit.Framework;
+
+namespace Algorithms.Tests.Sorters
+{
+    public static class RadixSorterTests
+    {
+        [Test]
+        public static void SortsArray([Random(0, 1000, 100, Distinct = true)]int n)
+        {
+            // Arrange
+            const int bits = 4;
+            var (correctArray, testArray) = RandomHelper.GetArrays(n);
+
+            // Act
+            RadixSorter.Sort(testArray, bits);
+            Array.Sort(correctArray);
+
+            // Assert
+            Assert.AreEqual(correctArray, testArray);
+        }
+    }
+}

Algorithms/Other/fermat_prime_checker.cs renamed to Algorithms/Other/FermatPrimeChecker.cs

@@ -1,23 +1,21 @@
 using System;
 using System.Numerics;
 
-namespace ConsoleTest
+namespace Algorithms.Other
 {
-    internal class Program
+    /// <summary>
+    /// Fermat's prime tester https://en.wikipedia.org/wiki/Fermat_primality_test.
+    /// </summary>
+    public static class FermatPrimeChecker
     {
-        // Fermat's prime tester https://en.wikipedia.org/wiki/Fermat_primality_test
-        private static void Main()
+        /// <summary>
+        /// Checks if input number is a probable prime.
+        /// </summary>
+        /// <param name="numberToTest">Input number.</param>
+        /// <param name="timesToCheck">Number of times to check.</param>
+        /// <returns>True if is a prime; False otherwise.</returns>
+        public static bool IsPrime(int numberToTest, int timesToCheck)
         {
-            Console.WriteLine("Welcome to Fermat's prime tester");
-            Console.WriteLine("--------------------------------");
-            Console.Write("Introduce a number to check if it is prime: ");
-            var numberToTestEntry = Console.ReadLine();
-            Console.Write("How many times this test is going to be run?: ");
-            var timesToCheckEntry = Console.ReadLine();
-
-            var numberToTest = int.Parse(numberToTestEntry);
-            var timesToCheck = int.Parse(timesToCheckEntry);
-
             // You have to use BigInteger for two reasons:
             //   1. The pow operation between two int numbers usually overflows an int
             //   2. The pow and modular operation is very optimized
@@ -42,13 +40,7 @@ private static void Main()
                 iterator++;
             }
 
-            if (prime)
-            {
-                Console.WriteLine($"The number {0} seems prime", numberToTestEntry);
-                return;
-            }
-
-            Console.WriteLine($"The number {0} isn't prime", numberToTestEntry);
+            return prime;
         }
     }
 }

Algorithms/Sorters/radix_sort.cs renamed to Algorithms/Sorters/RadixSorter.cs

@@ -1,15 +1,18 @@
-namespace radix_sort
+namespace Algorithms.Sorters
 {
-    internal class Program
+    /// <summary>
+    /// Radix sort is a non-comparative integer sorting algorithm that sorts data with integer keys by grouping keys by the individual
+    /// digits which share the same significant position and value. A positional notation is required, but because integers can represent
+    /// strings of characters (e.g., names or dates) and specially formatted floating point numbers, radix sort is not limited to integers.
+    /// </summary>
+    public static class RadixSorter
     {
         /// <summary>
-        /// Radix sort is a non-comparative integer sorting algorithm that sorts data with integer keys by grouping keys by the individual
-        /// digits which share the same significant position and value. A positional notation is required, but because integers can represent
-        /// strings of characters (e.g., names or dates) and specially formatted floating point numbers, radix sort is not limited to integers.
+        /// Sorts input array using radix sort algorithm.
         /// </summary>
         /// <param name="x">The x.</param>
-        /// <param name="bits">The bits.</param>
-        public static void RadixSort(ref int[] x, int bits)
+        /// <param name="bits">The number of bits our group will be long.</param>
+        public static void Sort(int[] x, int bits)
         {
             var b = new int[x.Length];
             var rshift = 0;