Add static modifier where possible (#108)

1fisedi · siriak · commit a3cbd0dc78ad · 2019-08-05T14:13:07.000+03:00
diff --git a/Algorithms.Tests/Compressors/HuffmanCompressorTests.cs b/Algorithms.Tests/Compressors/HuffmanCompressorTests.cs
@@ -5,15 +5,15 @@
 
 namespace Algorithms.Tests.Compressors
 {
-    public class HuffmanCompressorTests
+    public static class HuffmanCompressorTests
     {
         [Test]
         [TestCase("This is a string", "101010110111011101110111100011111010010010010011000")]
         [TestCase("Hello", "1101110010")]
         [TestCase("dddddddddd", "1111111111")]
         [TestCase("a", "1")]
         [TestCase("", "")]
-        public void CompressingPhrase(string uncompressedText, string expectedCompressedText)
+        public static void CompressingPhrase(string uncompressedText, string expectedCompressedText)
         {
             //Arrange
             var sorter = new BubbleSorter<HuffmanCompressor.ListNode>();
@@ -30,7 +30,7 @@ public void CompressingPhrase(string uncompressedText, string expectedCompressed
         }
 
         [Test]
-        public void DecompressedTextTheSameAsOriginal([Random(0, 1000, 100, Distinct = true)]int length)
+        public static void DecompressedTextTheSameAsOriginal([Random(0, 1000, 100, Distinct = true)]int length)
         {
             //Arrange
             var sorter = new BubbleSorter<HuffmanCompressor.ListNode>();
diff --git a/Algorithms.Tests/Compressors/ShannonFanoCompressorTests.cs b/Algorithms.Tests/Compressors/ShannonFanoCompressorTests.cs
@@ -5,13 +5,13 @@
 
 namespace Algorithms.Tests.Compressors
 {
-    public class ShannonFanoCompressorTests
+    public static class ShannonFanoCompressorTests
     {
         [Test]
         [TestCase("dddddddddd", "1111111111")]
         [TestCase("a", "1")]
         [TestCase("", "")]
-        public void CompressingPhrase(string uncompressedText, string expectedCompressedText)
+        public static void CompressingPhrase(string uncompressedText, string expectedCompressedText)
         {
             //Arrange
             var solver = new NaiveKnapsackSolver<(char, double)>();
@@ -28,7 +28,7 @@ public void CompressingPhrase(string uncompressedText, string expectedCompressed
         }
 
         [Test]
-        public void DecompressedTextTheSameAsOriginal([Random(0, 1000, 100)]int length)
+        public static void DecompressedTextTheSameAsOriginal([Random(0, 1000, 100)]int length)
         {
             //Arrange
             var solver = new NaiveKnapsackSolver<(char, double)>();
diff --git a/Algorithms.Tests/Compressors/TranslatorTests.cs b/Algorithms.Tests/Compressors/TranslatorTests.cs
@@ -4,10 +4,10 @@
 
 namespace Algorithms.Tests.Compressors
 {
-    public class TranslatorTests
+    public static class TranslatorTests
     {
         [Test]
-        public void TranslateCorrectly()
+        public static void TranslateCorrectly()
         {
             // Arrange
             var translator = new Translator();
diff --git a/Algorithms.Tests/Encoders/CaesarEncoderTests.cs b/Algorithms.Tests/Encoders/CaesarEncoderTests.cs
@@ -4,10 +4,10 @@
 
 namespace Algorithms.Tests.Encoders
 {
-    public class CaesarEncoderTests
+    public static class CaesarEncoderTests
     {
         [Test]
-        public void DecodedStringIsTheSame([Random(100)]int key)
+        public static void DecodedStringIsTheSame([Random(100)]int key)
         {
             // Arrange
             var encoder = new CaesarEncoder();
diff --git a/Algorithms.Tests/Encoders/HillEnconderTests.cs b/Algorithms.Tests/Encoders/HillEnconderTests.cs
@@ -4,12 +4,11 @@
 
 namespace Algorithms.Tests.Encoders
 {
-    public class HillEnconderTests
+    public static class HillEnconderTests
     {
-        // TODO: Add more random tests
         [Test]
         [Repeat(100)]
-        public void DecodedStringIsTheSame()
+        public static void DecodedStringIsTheSame()
         {
             // Arrange
             var encoder = new HillEncoder();
diff --git a/Algorithms.Tests/Encoders/VigenereEncoderTests.cs b/Algorithms.Tests/Encoders/VigenereEncoderTests.cs
@@ -4,11 +4,11 @@
 
 namespace Algorithms.Tests.Encoders
 {
-    public class VigenereEncoderTests
+    public static class VigenereEncoderTests
     {
         [Test]
         [Repeat(100)]
-        public void DecodedStringIsTheSame()
+        public static void DecodedStringIsTheSame()
         {
             // Arrange
             var random = new Randomizer();
diff --git a/Algorithms.Tests/Helpers/RandomHelper.cs b/Algorithms.Tests/Helpers/RandomHelper.cs
@@ -6,15 +6,17 @@ internal static class RandomHelper
     {
         public static (int[] correctArray, int[] testArray) GetArrays(int n)
         {
-            var testArray = new int[n];
+            var testArr = new int[n];
             var correctArray = new int[n];
+
             for (var i = 0; i < n; i++)
             {
                 var t = TestContext.CurrentContext.Random.Next(0, 1000);
-                testArray[i] = t;
+                testArr[i] = t;
                 correctArray[i] = t;
             }
-            return (correctArray, testArray);
+
+            return (correctArray, testArr);
         }
     }
 }
diff --git a/Algorithms.Tests/Knapsack/NaiveKnapsackSolverTests.cs b/Algorithms.Tests/Knapsack/NaiveKnapsackSolverTests.cs
@@ -4,10 +4,10 @@
 
 namespace Algorithms.Tests.Knapsack
 {
-    public class NaiveKnapsackSolverTests
+    public static class NaiveKnapsackSolverTests
     {
         [Test]
-        public void TakesHalf([Random(0, 1000, 100,Distinct = true)]int length)
+        public static void TakesHalf([Random(0, 1000, 100, Distinct = true)]int length)
         {
             //Arrange
             var solver = new NaiveKnapsackSolver<int>();
diff --git a/Algorithms.Tests/Numeric/GreatestCommonDivisor/BinaryGreatestCommonDivisorFinderTests.cs b/Algorithms.Tests/Numeric/GreatestCommonDivisor/BinaryGreatestCommonDivisorFinderTests.cs
@@ -3,7 +3,7 @@
 
 namespace Algorithms.Tests.Numeric.GreatestCommonDivisor
 {
-    public class BinaryGreatestCommonDivisorFinderTests
+    public static class BinaryGreatestCommonDivisorFinderTests
     {
         [Test]
         [TestCase(2, 3, 1)]
@@ -15,7 +15,7 @@ public class BinaryGreatestCommonDivisorFinderTests
         [TestCase(2 * 17, 17, 17)]
         [TestCase(0, 0, int.MaxValue)]
         [TestCase(2 * 13 * 17, 4 * 9 * 13, 2 * 13)]
-        public void GreatestCommonDivisorCorrect(int a, int b, int expectedGcd)
+        public static void GreatestCommonDivisorCorrect(int a, int b, int expectedGcd)
         {
             // Arrange
             var gcdFinder = new BinaryGreatestCommonDivisorFinder();
diff --git a/Algorithms.Tests/Numeric/GreatestCommonDivisor/EuclideanGreatestCommonDivisorFinderTests.cs b/Algorithms.Tests/Numeric/GreatestCommonDivisor/EuclideanGreatestCommonDivisorFinderTests.cs
@@ -3,7 +3,7 @@
 
 namespace Algorithms.Tests.Numeric.GreatestCommonDivisor
 {
-    public class EuclideanGreatestCommonDivisorFinderTests
+    public static class EuclideanGreatestCommonDivisorFinderTests
     {
         [Test]
         [TestCase(2, 3, 1)]
@@ -15,7 +15,7 @@ public class EuclideanGreatestCommonDivisorFinderTests
         [TestCase(2 * 17, 17, 17)]
         [TestCase(0, 0, int.MaxValue)]
         [TestCase(2 * 13 * 17, 4 * 9 * 13, 2 * 13)]
-        public void GreatestCommonDivisorCorrect(int a, int b, int expectedGcd)
+        public static void GreatestCommonDivisorCorrect(int a, int b, int expectedGcd)
         {
             // Arrange
             var gcdFinder = new EuclideanGreatestCommonDivisorFinder();
diff --git a/Algorithms.Tests/Other/SieveOfEratosthenesTests.cs b/Algorithms.Tests/Other/SieveOfEratosthenesTests.cs
@@ -4,7 +4,7 @@
 
 namespace Algorithms.Tests.Other
 {
-    public class SieveOfEratosthenesTests
+    public static class SieveOfEratosthenesTests
     {
         private static readonly BigInteger[] First10000PrimeNumbers =
         {
@@ -10011,6 +10011,6 @@ public class SieveOfEratosthenesTests
         };
 
         [Test]
-        public void First10_000PrimesCorrect() => Assert.AreEqual(First10000PrimeNumbers, SieveOfEratosthenes.GetPrimeNumbers(10_000));
+        public static void First10_000PrimesCorrect() => Assert.AreEqual(First10000PrimeNumbers, SieveOfEratosthenes.GetPrimeNumbers(10_000));
     }
 }
diff --git a/Algorithms.Tests/Search/BinarySearcherTests.cs b/Algorithms.Tests/Search/BinarySearcherTests.cs
@@ -5,10 +5,10 @@
 
 namespace Algorithms.Tests.Search
 {
-    public class BinarySearcherTests
+    public static class BinarySearcherTests
     {
         [Test]
-        public void FindIndex_ItemPresent_IndexCorrect([Random(1, 1000, 100)]int n)
+        public static void FindIndex_ItemPresent_IndexCorrect([Random(1, 1000, 100)]int n)
         {
             // Arrange
             var searcher = new BinarySearcher<int>();
@@ -24,7 +24,7 @@ public void FindIndex_ItemPresent_IndexCorrect([Random(1, 1000, 100)]int n)
         }
 
         [Test]
-        public void FindIndex_ItemMissing_MinusOneReturned([Random(0, 1000, 10)]int n, [Random(-100, 1100, 10)]int missingItem)
+        public static void FindIndex_ItemMissing_MinusOneReturned([Random(0, 1000, 10)]int n, [Random(-100, 1100, 10)]int missingItem)
         {
             // Arrange
             var searcher = new BinarySearcher<int>();
@@ -39,7 +39,7 @@ public void FindIndex_ItemMissing_MinusOneReturned([Random(0, 1000, 10)]int n, [
         }
 
         [Test]
-        public void FindIndex_ArrayEmpty_MinusOneReturned([Random(100)]int itemToSearch)
+        public static void FindIndex_ArrayEmpty_MinusOneReturned([Random(100)]int itemToSearch)
         {
             // Arrange
             var searcher = new BinarySearcher<int>();
diff --git a/Algorithms.Tests/Search/LinearSearcherTests.cs b/Algorithms.Tests/Search/LinearSearcherTests.cs
@@ -6,10 +6,10 @@
 
 namespace Algorithms.Tests.Search
 {
-    public class LinearSearcherTests
+    public static class LinearSearcherTests
     {
         [Test]
-        public void Find_ItemPresent_ItemCorrect([Random(0, 1_000_000, 100)]int n)
+        public static void Find_ItemPresent_ItemCorrect([Random(0, 1_000_000, 100)]int n)
         {
             // Arrange
             var searcher = new LinearSearcher<int>();
@@ -25,7 +25,7 @@ public void Find_ItemPresent_ItemCorrect([Random(0, 1_000_000, 100)]int n)
         }
 
         [Test]
-        public void FindIndex_ItemPresent_IndexCorrect([Random(0, 1_000_000, 100)]int n)
+        public static void FindIndex_ItemPresent_IndexCorrect([Random(0, 1_000_000, 100)]int n)
         {
             // Arrange
             var searcher = new LinearSearcher<int>();
@@ -41,7 +41,7 @@ public void FindIndex_ItemPresent_IndexCorrect([Random(0, 1_000_000, 100)]int n)
         }
 
         [Test]
-        public void Find_ItemMissing_ItemNotFoundExceptionThrown([Random(0, 1_000_000, 100)]int n)
+        public static void Find_ItemMissing_ItemNotFoundExceptionThrown([Random(0, 1_000_000, 100)]int n)
         {
             // Arrange
             var searcher = new LinearSearcher<int>();
@@ -54,7 +54,7 @@ public void Find_ItemMissing_ItemNotFoundExceptionThrown([Random(0, 1_000_000, 1
         }
 
         [Test]
-        public void FindIndex_ItemMissing_MinusOneReturned([Random(0, 1_000_000, 100)]int n)
+        public static void FindIndex_ItemMissing_MinusOneReturned([Random(0, 1_000_000, 100)]int n)
         {
             // Arrange
             var searcher = new LinearSearcher<int>();
diff --git a/Algorithms.Tests/Sorters/BinaryInsertionSorterTests.cs b/Algorithms.Tests/Sorters/BinaryInsertionSorterTests.cs
@@ -5,10 +5,10 @@
 
 namespace Algorithms.Tests.Sorters
 {
-    public class BinaryInsertionSorterTests
+    public static class BinaryInsertionSorterTests
     {
         [Test]
-        public void ArraySorted([Random(0, 1000, 100, Distinct = true)]int n)
+        public static void ArraySorted([Random(0, 1000, 100, Distinct = true)]int n)
         {
             // Arrange
             var sorter = new BinaryInsertionSorter<int>();
diff --git a/Algorithms.Tests/Sorters/BogoSorterTests.cs b/Algorithms.Tests/Sorters/BogoSorterTests.cs
@@ -5,10 +5,10 @@
 
 namespace Algorithms.Tests.Sorters
 {
-    public class BogoSorterTests
+    public static class BogoSorterTests
     {
         [Test]
-        public void ArraySorted([Random(0, 10, 10, Distinct = true)]int n)
+        public static void ArraySorted([Random(0, 10, 10, Distinct = true)]int n)
         {
             // Arrange
             var sorter = new BogoSorter<int>();
diff --git a/Algorithms.Tests/Sorters/BubbleSorterTests.cs b/Algorithms.Tests/Sorters/BubbleSorterTests.cs
@@ -7,10 +7,10 @@
 
 namespace Algorithms.Tests.Sorters
 {
-    public class BubbleSorterTests
+    public static class BubbleSorterTests
     {
         [Test]
-        public void ArraySorted([Random(0, 1000, 100, Distinct = true)]int n)
+        public static void ArraySorted([Random(0, 1000, 100, Distinct = true)]int n)
         {
             // Arrange
             var sorter = new BubbleSorter<int>();
diff --git a/Algorithms.Tests/Sorters/HeapSorterTests.cs b/Algorithms.Tests/Sorters/HeapSorterTests.cs
@@ -1,8 +1,6 @@
 ﻿using System;
-
 using Algorithms.Sorters;
 using Algorithms.Tests.Helpers;
-
 using NUnit.Framework;
 
 namespace Algorithms.Tests.Sorters
diff --git a/Algorithms.Tests/Sorters/InsertionSorterTests.cs b/Algorithms.Tests/Sorters/InsertionSorterTests.cs
@@ -5,10 +5,10 @@
 
 namespace Algorithms.Tests.Sorters
 {
-    public class InsertionSorterTests
+    public static class InsertionSorterTests
     {
         [Test]
-        public void ArraySorted([Random(0, 1000, 100, Distinct = true)]int n)
+        public static void ArraySorted([Random(0, 1000, 100, Distinct = true)]int n)
         {
             // Arrange
             var sorter = new InsertionSorter<int>();
diff --git a/Algorithms.Tests/Sorters/PancakeSorterTests.cs b/Algorithms.Tests/Sorters/PancakeSorterTests.cs
@@ -5,10 +5,10 @@
 
 namespace Algorithms.Tests.Sorters
 {
-    public class PancakeSorterTests
+    public static class PancakeSorterTests
     {
         [Test]
-        public void ArraySorted([Random(0, 1000, 100, Distinct = true)]int n)
+        public static void ArraySorted([Random(0, 1000, 100, Distinct = true)]int n)
         {
             // Arrange
             var sorter = new PancakeSorter<int>();
diff --git a/Algorithms.Tests/Sorters/QuickSorterTests.cs b/Algorithms.Tests/Sorters/QuickSorterTests.cs
@@ -5,10 +5,10 @@
 
 namespace Algorithms.Tests.Sorters
 {
-    public class QuickSorterTests
+    public static class QuickSorterTests
     {
         [Test]
-        public void ArraySorted([Random(0, 1000, 100, Distinct = true)]int n)
+        public static void ArraySorted([Random(0, 1000, 100, Distinct = true)]int n)
         {
             // Arrange
             var sorter = new QuickSorter<int>();
diff --git a/Algorithms.Tests/Sorters/SelectionSorterTests.cs b/Algorithms.Tests/Sorters/SelectionSorterTests.cs
@@ -5,10 +5,10 @@
 
 namespace Algorithms.Tests.Sorters
 {
-    public class SelectionSorterTests
+    public static class SelectionSorterTests
     {
         [Test]
-        public void ArraySorted([Random(0, 1000, 100, Distinct = true)]int n)
+        public static void ArraySorted([Random(0, 1000, 100, Distinct = true)]int n)
         {
             // Arrange
             var sorter = new SelectionSorter<int>();
diff --git a/Algorithms.Tests/Sorters/ShellSorterTests.cs b/Algorithms.Tests/Sorters/ShellSorterTests.cs
@@ -5,10 +5,10 @@
 
 namespace Algorithms.Tests.Sorters
 {
-    public class ShellSorterTests
+    public static class ShellSorterTests
     {
         [Test]
-        public void ArraySorted([Random(0, 1000, 100, Distinct = true)]int n)
+        public static void ArraySorted([Random(0, 1000, 100, Distinct = true)]int n)
         {
             // Arrange
             var sorter = new ShellSorter<int>();
diff --git a/Algorithms.Tests/Strings/GeneralStringAlgorithmsTests.cs b/Algorithms.Tests/Strings/GeneralStringAlgorithmsTests.cs
@@ -4,13 +4,13 @@
 
 namespace Algorithms.Tests.Strings
 {
-    public class GeneralStringAlgorithmsTests
+    public static class GeneralStringAlgorithmsTests
     {
         [Test]
         [TestCase("Griffith", 'f', 2)]
         [TestCase("Randomwoooord", 'o', 4)]
         [TestCase("Control", 'C', 1)]
-        public void MaxCountCharIsObtained(string text, char expectedSymbol, int expectedCount)
+        public static void MaxCountCharIsObtained(string text, char expectedSymbol, int expectedCount)
         {
             // Arrange
             // Act
diff --git a/Algorithms.Tests/Strings/PalindromeTests.cs b/Algorithms.Tests/Strings/PalindromeTests.cs
diff --git a/Algorithms/DataCompression/HuffmanCompressor.cs b/Algorithms/DataCompression/HuffmanCompressor.cs
diff --git a/DataStructures.Tests/LinkedList/LinkedListTests.cs b/DataStructures.Tests/LinkedList/LinkedListTests.cs
diff --git a/DataStructures/SinglyLinkedList/SinglyLinkedList.cs b/DataStructures/SinglyLinkedList/SinglyLinkedList.cs

Original file line number	Diff line number	Diff line change
`@@ -5,15 +5,15 @@`
`5`	`5`
`6`	`6`	`namespace Algorithms.Tests.Compressors`
`7`	`7`	`{`
`8`		`- public class HuffmanCompressorTests`
	`8`	`+ public static class HuffmanCompressorTests`
`9`	`9`	`{`
`10`	`10`	`[Test]`
`11`	`11`	`[TestCase("This is a string", "101010110111011101110111100011111010010010010011000")]`
`12`	`12`	`[TestCase("Hello", "1101110010")]`
`13`	`13`	`[TestCase("dddddddddd", "1111111111")]`
`14`	`14`	`[TestCase("a", "1")]`
`15`	`15`	`[TestCase("", "")]`
`16`		`- public void CompressingPhrase(string uncompressedText, string expectedCompressedText)`
	`16`	`+ public static void CompressingPhrase(string uncompressedText, string expectedCompressedText)`
`17`	`17`	`{`
`18`	`18`	`//Arrange`
`19`	`19`	`var sorter = new BubbleSorter<HuffmanCompressor.ListNode>();`
`@@ -30,7 +30,7 @@ public void CompressingPhrase(string uncompressedText, string expectedCompressed`
`30`	`30`	`}`
`31`	`31`
`32`	`32`	`[Test]`
`33`		`- public void DecompressedTextTheSameAsOriginal([Random(0, 1000, 100, Distinct = true)]int length)`
	`33`	`+ public static void DecompressedTextTheSameAsOriginal([Random(0, 1000, 100, Distinct = true)]int length)`
`34`	`34`	`{`
`35`	`35`	`//Arrange`
`36`	`36`	`var sorter = new BubbleSorter<HuffmanCompressor.ListNode>();`
Original file line number	Diff line number	Diff line change
`@@ -5,13 +5,13 @@`
`5`	`5`
`6`	`6`	`namespace Algorithms.Tests.Compressors`
`7`	`7`	`{`
`8`		`- public class ShannonFanoCompressorTests`
	`8`	`+ public static class ShannonFanoCompressorTests`
`9`	`9`	`{`
`10`	`10`	`[Test]`
`11`	`11`	`[TestCase("dddddddddd", "1111111111")]`
`12`	`12`	`[TestCase("a", "1")]`
`13`	`13`	`[TestCase("", "")]`
`14`		`- public void CompressingPhrase(string uncompressedText, string expectedCompressedText)`
	`14`	`+ public static void CompressingPhrase(string uncompressedText, string expectedCompressedText)`
`15`	`15`	`{`
`16`	`16`	`//Arrange`
`17`	`17`	`var solver = new NaiveKnapsackSolver<(char, double)>();`
`@@ -28,7 +28,7 @@ public void CompressingPhrase(string uncompressedText, string expectedCompressed`
`28`	`28`	`}`
`29`	`29`
`30`	`30`	`[Test]`
`31`		`- public void DecompressedTextTheSameAsOriginal([Random(0, 1000, 100)]int length)`
	`31`	`+ public static void DecompressedTextTheSameAsOriginal([Random(0, 1000, 100)]int length)`
`32`	`32`	`{`
`33`	`33`	`//Arrange`
`34`	`34`	`var solver = new NaiveKnapsackSolver<(char, double)>();`
Original file line number	Diff line number	Diff line change
`@@ -4,10 +4,10 @@`
`4`	`4`
`5`	`5`	`namespace Algorithms.Tests.Compressors`
`6`	`6`	`{`
`7`		`- public class TranslatorTests`
	`7`	`+ public static class TranslatorTests`
`8`	`8`	`{`
`9`	`9`	`[Test]`
`10`		`- public void TranslateCorrectly()`
	`10`	`+ public static void TranslateCorrectly()`
`11`	`11`	`{`
`12`	`12`	`// Arrange`
`13`	`13`	`var translator = new Translator();`
Original file line number	Diff line number	Diff line change
`@@ -4,10 +4,10 @@`
`4`	`4`
`5`	`5`	`namespace Algorithms.Tests.Encoders`
`6`	`6`	`{`
`7`		`- public class CaesarEncoderTests`
	`7`	`+ public static class CaesarEncoderTests`
`8`	`8`	`{`
`9`	`9`	`[Test]`
`10`		`- public void DecodedStringIsTheSame([Random(100)]int key)`
	`10`	`+ public static void DecodedStringIsTheSame([Random(100)]int key)`
`11`	`11`	`{`
`12`	`12`	`// Arrange`
`13`	`13`	`var encoder = new CaesarEncoder();`
Original file line number	Diff line number	Diff line change
`@@ -4,12 +4,11 @@`
`4`	`4`
`5`	`5`	`namespace Algorithms.Tests.Encoders`
`6`	`6`	`{`
`7`		`- public class HillEnconderTests`
	`7`	`+ public static class HillEnconderTests`
`8`	`8`	`{`
`9`		`- // TODO: Add more random tests`
`10`	`9`	`[Test]`
`11`	`10`	`[Repeat(100)]`
`12`		`- public void DecodedStringIsTheSame()`
	`11`	`+ public static void DecodedStringIsTheSame()`
`13`	`12`	`{`
`14`	`13`	`// Arrange`
`15`	`14`	`var encoder = new HillEncoder();`
Original file line number	Diff line number	Diff line change
`@@ -4,11 +4,11 @@`
`4`	`4`
`5`	`5`	`namespace Algorithms.Tests.Encoders`
`6`	`6`	`{`
`7`		`- public class VigenereEncoderTests`
	`7`	`+ public static class VigenereEncoderTests`
`8`	`8`	`{`
`9`	`9`	`[Test]`
`10`	`10`	`[Repeat(100)]`
`11`		`- public void DecodedStringIsTheSame()`
	`11`	`+ public static void DecodedStringIsTheSame()`
`12`	`12`	`{`
`13`	`13`	`// Arrange`
`14`	`14`	`var random = new Randomizer();`
Original file line number	Diff line number	Diff line change
`@@ -6,15 +6,17 @@ internal static class RandomHelper`
`6`	`6`	`{`
`7`	`7`	`public static (int[] correctArray, int[] testArray) GetArrays(int n)`
`8`	`8`	`{`
`9`		`- var testArray = new int[n];`
	`9`	`+ var testArr = new int[n];`
`10`	`10`	`var correctArray = new int[n];`
	`11`	`+`
`11`	`12`	`for (var i = 0; i < n; i++)`
`12`	`13`	`{`
`13`	`14`	`var t = TestContext.CurrentContext.Random.Next(0, 1000);`
`14`		`- testArray[i] = t;`
	`15`	`+ testArr[i] = t;`
`15`	`16`	`correctArray[i] = t;`
`16`	`17`	`}`
`17`		`- return (correctArray, testArray);`
	`18`	`+`
	`19`	`+ return (correctArray, testArr);`
`18`	`20`	`}`
`19`	`21`	`}`
`20`	`22`	`}`
Original file line number	Diff line number	Diff line change
`@@ -4,10 +4,10 @@`
`4`	`4`
`5`	`5`	`namespace Algorithms.Tests.Knapsack`
`6`	`6`	`{`
`7`		`- public class NaiveKnapsackSolverTests`
	`7`	`+ public static class NaiveKnapsackSolverTests`
`8`	`8`	`{`
`9`	`9`	`[Test]`
`10`		`- public void TakesHalf([Random(0, 1000, 100,Distinct = true)]int length)`
	`10`	`+ public static void TakesHalf([Random(0, 1000, 100, Distinct = true)]int length)`
`11`	`11`	`{`
`12`	`12`	`//Arrange`
`13`	`13`	`var solver = new NaiveKnapsackSolver<int>();`
Original file line number	Diff line number	Diff line change
`@@ -3,7 +3,7 @@`
`3`	`3`
`4`	`4`	`namespace Algorithms.Tests.Numeric.GreatestCommonDivisor`
`5`	`5`	`{`
`6`		`- public class BinaryGreatestCommonDivisorFinderTests`
	`6`	`+ public static class BinaryGreatestCommonDivisorFinderTests`
`7`	`7`	`{`
`8`	`8`	`[Test]`
`9`	`9`	`[TestCase(2, 3, 1)]`
`@@ -15,7 +15,7 @@ public class BinaryGreatestCommonDivisorFinderTests`
`15`	`15`	`[TestCase(2 * 17, 17, 17)]`
`16`	`16`	`[TestCase(0, 0, int.MaxValue)]`
`17`	`17`	`[TestCase(2 * 13 * 17, 4 * 9 * 13, 2 * 13)]`
`18`		`- public void GreatestCommonDivisorCorrect(int a, int b, int expectedGcd)`
	`18`	`+ public static void GreatestCommonDivisorCorrect(int a, int b, int expectedGcd)`
`19`	`19`	`{`
`20`	`20`	`// Arrange`
`21`	`21`	`var gcdFinder = new BinaryGreatestCommonDivisorFinder();`
Original file line number	Diff line number	Diff line change
`@@ -3,7 +3,7 @@`
`3`	`3`
`4`	`4`	`namespace Algorithms.Tests.Numeric.GreatestCommonDivisor`
`5`	`5`	`{`
`6`		`- public class EuclideanGreatestCommonDivisorFinderTests`
	`6`	`+ public static class EuclideanGreatestCommonDivisorFinderTests`
`7`	`7`	`{`
`8`	`8`	`[Test]`
`9`	`9`	`[TestCase(2, 3, 1)]`
`@@ -15,7 +15,7 @@ public class EuclideanGreatestCommonDivisorFinderTests`
`15`	`15`	`[TestCase(2 * 17, 17, 17)]`
`16`	`16`	`[TestCase(0, 0, int.MaxValue)]`
`17`	`17`	`[TestCase(2 * 13 * 17, 4 * 9 * 13, 2 * 13)]`
`18`		`- public void GreatestCommonDivisorCorrect(int a, int b, int expectedGcd)`
	`18`	`+ public static void GreatestCommonDivisorCorrect(int a, int b, int expectedGcd)`
`19`	`19`	`{`
`20`	`20`	`// Arrange`
`21`	`21`	`var gcdFinder = new EuclideanGreatestCommonDivisorFinder();`