Remove redundant attributes (#438)

siriak · web-flow · commit 9b9c5b6afb85 · 2024-01-10T22:44:10.000+02:00
diff --git a/Algorithms.Tests/Compressors/BurrowsWheelerTransformTests.cs b/Algorithms.Tests/Compressors/BurrowsWheelerTransformTests.cs
@@ -6,7 +6,6 @@ namespace Algorithms.Tests.Compressors;
 
 public class BurrowsWheelerTransformTests
 {
-    [Test]
     [TestCase("banana", "nnbaaa", 3)]
     [TestCase("SIX.MIXED.PIXIES.SIFT.SIXTY.PIXIE.DUST.BOXES", "TEXYDST.E.IXIXIXXSSMPPS.B..E.S.EUSFXDIIOIIIT", 29)]
     [TestCase("", "", 0)]
@@ -20,7 +19,6 @@ public void Encode(string input, string expectedString, int expectedIndex)
         Assert.AreEqual(expectedIndex, index);
     }
 
-    [Test]
     [TestCase("nnbaaa", 3, "banana")]
     [TestCase("TEXYDST.E.IXIXIXXSSMPPS.B..E.S.EUSFXDIIOIIIT", 29, "SIX.MIXED.PIXIES.SIFT.SIXTY.PIXIE.DUST.BOXES")]
     [TestCase("", 0, "")]
diff --git a/Algorithms.Tests/Compressors/HuffmanCompressorTests.cs b/Algorithms.Tests/Compressors/HuffmanCompressorTests.cs
@@ -8,7 +8,6 @@ namespace Algorithms.Tests.Compressors;
 
 public static class HuffmanCompressorTests
 {
-    [Test]
     [TestCase("This is a string", "101010110111011101110111100011111010010010010011000")]
     [TestCase("Hello", "1101110010")]
     [TestCase("dddddddddd", "1111111111")]
diff --git a/Algorithms.Tests/Compressors/ShannonFanoCompressorTests.cs b/Algorithms.Tests/Compressors/ShannonFanoCompressorTests.cs
@@ -7,7 +7,6 @@ namespace Algorithms.Tests.Compressors;
 
 public static class ShannonFanoCompressorTests
 {
-    [Test]
     [TestCase("dddddddddd", "1111111111")]
     [TestCase("a", "1")]
     [TestCase("", "")]
diff --git a/Algorithms.Tests/Encoders/FeistelCipherTest.cs b/Algorithms.Tests/Encoders/FeistelCipherTest.cs
@@ -26,7 +26,6 @@ public static void DecodedStringIsTheSame([Random(100)] uint key)
         Assert.AreEqual(message, decoded);
     }
 
-    [Test]
     [TestCase("00001111",                           (uint)0x12345678)]
     [TestCase("00001111222233334444555566667",      (uint)0x12345678)]
     [TestCase("000011112222333344445555666677",     (uint)0x12345678)]
diff --git a/Algorithms.Tests/Graph/BreadthFirstTreeTraversalTests.cs b/Algorithms.Tests/Graph/BreadthFirstTreeTraversalTests.cs
@@ -39,7 +39,6 @@ public static void EmptyArrayForNullRoot()
         Assert.IsEmpty(levelOrder);
     }
 
-    [Test]
     [TestCase(new [] {7, 9, 5})]
     [TestCase(new [] { 7, 13, 11, 15, 14, 4, 5, 16, 2 })]
     public static void IncorrectLevelOrderTraversal(int[] insertion)
diff --git a/Algorithms.Tests/LinearAlgebra/Distances/EuclideanTests.cs b/Algorithms.Tests/LinearAlgebra/Distances/EuclideanTests.cs
@@ -8,12 +8,11 @@ namespace Algorithms.Tests.LinearAlgebra.Distances;
 public static class EuclideanTests
 {
     /// <summary>
-    /// Test the result given by Euclidean distance function. 
+    /// Test the result given by Euclidean distance function.
     /// </summary>
     /// <param name="point1">Origin point.</param>
     /// <param name="point2">Target point.</param>
     /// <param name="expectedResult">Expected result.</param>
-    [Test]
     [TestCase(new[] { 1.5 }, new[] { -1.0 }, 2.5)]
     [TestCase(new[] { 7.0, 4.0, 3.0 }, new[] { 17.0, 6.0, 2.0 }, 10.247)]
     public static void DistanceTest(double[] point1, double[] point2, double expectedResult)
@@ -26,7 +25,6 @@ public static void DistanceTest(double[] point1, double[] point2, double expecte
     /// </summary>
     /// <param name="point1">First point of N dimensions.</param>
     /// <param name="point2">Second point of M dimensions, M != N.</param>
-    [Test]
     [TestCase(new[] { 7.0, 4.5 }, new[] { -3.0 })]
     [TestCase(new[] { 12.0 }, new[] { 1.5, 7.0, 3.2 })]
     public static void DistanceThrowsArgumentExceptionOnDifferentPointDimensions(double[] point1, double[] point2)
diff --git a/Algorithms.Tests/LinearAlgebra/Distances/ManhattanTests.cs b/Algorithms.Tests/LinearAlgebra/Distances/ManhattanTests.cs
@@ -8,12 +8,11 @@ namespace Algorithms.Tests.LinearAlgebra.Distances;
 public class ManhattanTests
 {
     /// <summary>
-    /// Test the result given by Manhattan distance function. 
+    /// Test the result given by Manhattan distance function.
     /// </summary>
     /// <param name="point1">Origin point.</param>
     /// <param name="point2">Target point.</param>
     /// <param name="expectedDistance">Expected result.</param>
-    [Test]
     [TestCase(new[] { 1.5 }, new[] { -1.0 }, 2.5)]
     [TestCase(new[] { 2.0, 3.0 }, new[] { -1.0, 5.0 }, 5)]
     [TestCase(new[] { 1.0, 2.0, 3.0 }, new[] { 1.0, 2.0, 3.0 }, 0)]
@@ -28,7 +27,6 @@ public void DistanceTest(double[] point1, double[] point2, double expectedDistan
     /// </summary>
     /// <param name="point1">First point of N dimensions.</param>
     /// <param name="point2">Second point of M dimensions, M != N.</param>
-    [Test]
     [TestCase(new[] { 2.0, 3.0 }, new[] { -1.0 })]
     [TestCase(new[] { 1.0 }, new[] { 1.0, 2.0, 3.0 })]
     public void DistanceThrowsArgumentExceptionOnDifferentPointDimensions(double[] point1, double[] point2)
diff --git a/Algorithms.Tests/ModularArithmetic/ExtendedEuclideanAlgorithmTest.cs b/Algorithms.Tests/ModularArithmetic/ExtendedEuclideanAlgorithmTest.cs
@@ -6,7 +6,6 @@ namespace Algorithms.Tests.ModularArithmetic;
 
 public static class ExtendedEuclideanAlgorithmTest
 {
-    [Test]
     [TestCase(240, 46, 2, -9, 47)]
     [TestCase(46, 240, 2, 47, -9)]
     [TestCase(2, 3, 1, -1, 1)]
@@ -29,7 +28,6 @@ public static void TestCompute(long a, long b, long expectedGCD, long expectedBe
         Assert.AreEqual(expectedBezoutOfB, eeaResult.bezoutB);
     }
 
-    [Test]
     [TestCase(240, 46, 2, -9, 47)]
     [TestCase(46, 240, 2, 47, -9)]
     [TestCase(2, 3, 1, -1, 1)]
diff --git a/Algorithms.Tests/ModularArithmetic/ModularMultiplicativeInverseTest.cs b/Algorithms.Tests/ModularArithmetic/ModularMultiplicativeInverseTest.cs
@@ -7,7 +7,6 @@ namespace Algorithms.Tests.ModularArithmetic;
 
 public static class ModularMultiplicativeInverseTest
 {
-    [Test]
     [TestCase(2, 3, 2)]
     [TestCase(1, 1, 0)]
     [TestCase(13, 17, 4)]
@@ -20,7 +19,6 @@ public static void TestCompute(long a, long n, long expected)
         Assert.AreEqual(expected, inverse);
     }
 
-    [Test]
     [TestCase(46, 240)]
     [TestCase(0, 17)]
     [TestCase(17, 0)]
@@ -36,7 +34,6 @@ public static void TestCompute_Irrevertible(long a, long n)
         _ = Assert.Throws<ArithmeticException>(Act);
     }
 
-    [Test]
     [TestCase(2, 3, 2)]
     [TestCase(1, 1, 0)]
     [TestCase(13, 17, 4)]
@@ -49,7 +46,6 @@ public static void TestCompute_BigInteger(long a, long n, long expected)
         Assert.AreEqual(new BigInteger(expected), inverse);
     }
 
-    [Test]
     [TestCase(46, 240)]
     [TestCase(0, 17)]
     [TestCase(17, 0)]
diff --git a/Algorithms.Tests/Numeric/AliquotSumCalculatorTests.cs b/Algorithms.Tests/Numeric/AliquotSumCalculatorTests.cs
@@ -7,7 +7,6 @@ namespace Algorithms.Tests.Numeric;
 
 public static class AliquotSumCalculatorTests
 {
-    [Test]
     [TestCase(1, 0)]
     [TestCase(3, 1)]
     [TestCase(25, 6)]
@@ -23,7 +22,6 @@ public static void CalculateSum_SumIsCorrect(int number, int expectedSum)
         result.Should().Be(expectedSum);
     }
 
-    [Test]
     [TestCase(-2)]
     public static void CalculateSum_NegativeInput_ExceptionIsThrown(int number)
     {
diff --git a/Algorithms.Tests/Numeric/AmicableNumbersTest.cs b/Algorithms.Tests/Numeric/AmicableNumbersTest.cs
@@ -5,7 +5,6 @@ namespace Algorithms.Tests.Numeric;
 
 public static class AmicableNumbersTest
 {
-    [Test]
     [TestCase(220, 284)]
     [TestCase(1184, 1210)]
     [TestCase(2620, 2924)]
diff --git a/Algorithms.Tests/Numeric/BinomialCoefficientTests.cs b/Algorithms.Tests/Numeric/BinomialCoefficientTests.cs
@@ -20,7 +20,6 @@ public static void CalculateFromPairs(int n, int k, int expected)
         Assert.AreEqual(new BigInteger(expected), result);
     }
 
-    [Test]
     [TestCase(3, 7)]
     public static void TeoremCalculateThrowsException(int n, int k)
     {
diff --git a/Algorithms.Tests/Numeric/Factorization/TrialDivisionFactorizerTests.cs b/Algorithms.Tests/Numeric/Factorization/TrialDivisionFactorizerTests.cs
@@ -5,7 +5,6 @@ namespace Algorithms.Tests.Numeric.Factorization;
 
 public static class TrialDivisionFactorizerTests
 {
-    [Test]
     [TestCase(2)]
     [TestCase(3)]
     [TestCase(29)]
@@ -22,7 +21,6 @@ public static void PrimeNumberFactorizationFails(int p)
         Assert.IsFalse(success);
     }
 
-    [Test]
     [TestCase(4, 2)]
     [TestCase(6, 2)]
     [TestCase(8, 2)]
diff --git a/Algorithms.Tests/Numeric/GreatestCommonDivisor/BinaryGreatestCommonDivisorFinderTests.cs b/Algorithms.Tests/Numeric/GreatestCommonDivisor/BinaryGreatestCommonDivisorFinderTests.cs
@@ -5,7 +5,6 @@ namespace Algorithms.Tests.Numeric.GreatestCommonDivisor;
 
 public static class BinaryGreatestCommonDivisorFinderTests
 {
-    [Test]
     [TestCase(2, 3, 1)]
     [TestCase(1, 1, 1)]
     [TestCase(13, 17, 1)]
diff --git a/Algorithms.Tests/Numeric/GreatestCommonDivisor/EuclideanGreatestCommonDivisorFinderTests.cs b/Algorithms.Tests/Numeric/GreatestCommonDivisor/EuclideanGreatestCommonDivisorFinderTests.cs
@@ -5,7 +5,6 @@ namespace Algorithms.Tests.Numeric.GreatestCommonDivisor;
 
 public static class EuclideanGreatestCommonDivisorFinderTests
 {
-    [Test]
     [TestCase(2, 3, 1)]
     [TestCase(1, 1, 1)]
     [TestCase(13, 17, 1)]
diff --git a/Algorithms.Tests/Numeric/KeithNumberTest.cs b/Algorithms.Tests/Numeric/KeithNumberTest.cs
@@ -6,7 +6,6 @@ namespace Algorithms.Tests.Numeric;
 
 public static class KeithNumberTest
 {
-    [Test]
     [TestCase(14)]
     [TestCase(47)]
     [TestCase(197)]
@@ -20,7 +19,6 @@ public static void KeithNumberWork(int number)
         Assert.IsTrue(result);
     }
 
-    [Test]
     [TestCase(-2)]
     public static void KeithNumberShouldThrowEx(int number)
     {
diff --git a/Algorithms.Tests/Numeric/ModularExponentiationTest.cs b/Algorithms.Tests/Numeric/ModularExponentiationTest.cs
@@ -7,7 +7,6 @@ namespace Algorithms.Tests.Numeric;
 
 public class ModularExponentiationTest
 {
-    [Test]
     [TestCase(3, 6, 11, 3)]
     [TestCase(5, 3, 13, 8)]
     [TestCase(2, 7, 17, 9)]
diff --git a/Algorithms.Tests/Numeric/NarcissisticNumberTest.cs b/Algorithms.Tests/Numeric/NarcissisticNumberTest.cs
@@ -5,7 +5,6 @@ namespace Algorithms.Tests.Numeric;
 
 public static class NarcissisticNumberTest
 {
-    [Test]
     [TestCase(2, ExpectedResult = true)]
     [TestCase(3, ExpectedResult = true)]
     [TestCase(28, ExpectedResult = false)]
diff --git a/Algorithms.Tests/Numeric/PerfectNumberTest.cs b/Algorithms.Tests/Numeric/PerfectNumberTest.cs
@@ -6,7 +6,6 @@ namespace Algorithms.Tests.Numeric;
 
 public static class PerfectNumberTests
 {
-    [Test]
     [TestCase(6)]
     [TestCase(28)]
     [TestCase(496)]
@@ -22,7 +21,6 @@ public static void PerfectNumberWork(int number)
         Assert.IsTrue(result);
     }
 
-    [Test]
     [TestCase(-2)]
     public static void PerfectNumberShouldThrowEx(int number)
     {
diff --git a/Algorithms.Tests/Numeric/PerfectSquareTest.cs b/Algorithms.Tests/Numeric/PerfectSquareTest.cs
@@ -5,7 +5,6 @@ namespace Algorithms.Tests.Numeric;
 
 public static class PerfectSquareTests
 {
-    [Test]
     [TestCase(-4, ExpectedResult = false)]
     [TestCase(4, ExpectedResult = true)]
     [TestCase(9, ExpectedResult = true)]
diff --git a/Algorithms.Tests/Other/FermatPrimeCheckerTests.cs b/Algorithms.Tests/Other/FermatPrimeCheckerTests.cs
@@ -6,7 +6,6 @@ namespace Algorithms.Tests.Other;
 
 public static class FermatPrimeCheckerTests
 {
-    [Test]
     [TestCase(5, true)]
     [TestCase(2633, true)]
     [TestCase(9439, true)]
diff --git a/Algorithms.Tests/Other/GeoLocationTests.cs b/Algorithms.Tests/Other/GeoLocationTests.cs
@@ -6,7 +6,6 @@ namespace Algorithms.Tests.Other;
 
 public static class GeoLocationTests
 {
-    [Test]
     [TestCase(53.430488d, -2.96129d, 53.430488d, -2.96129d, 0d)]
     [TestCase(53.430971d, -2.959806d, 53.430242d, -2.960830d, 105d)]
     public static void CalculateDistanceFromLatLngTest(
diff --git a/Algorithms.Tests/Other/Int2BinaryTests.cs b/Algorithms.Tests/Other/Int2BinaryTests.cs
@@ -5,7 +5,6 @@ namespace Algorithms.Tests.Other;
 
 public static class Int2BinaryTests
 {
-    [Test]
     [TestCase((ushort)0, "0000000000000000")]
     [TestCase((ushort)0b1, "0000000000000001")]
     [TestCase((ushort)0b0001010100111000, "0001010100111000")]
@@ -24,7 +23,6 @@ public static void GetsBinary(ushort input, string expected)
     }
 
 
-    [Test]
     [TestCase((uint)0, "00000000000000000000000000000000")]
     [TestCase((uint)0b1, "00000000000000000000000000000001")]
     [TestCase((uint)0b0001010100111000, "00000000000000000001010100111000")]
@@ -43,7 +41,6 @@ public static void GetsBinary(uint input, string expected)
         Assert.AreEqual(expected, result);
     }
 
-    [Test]
     [TestCase((ulong)0, "0000000000000000000000000000000000000000000000000000000000000000")]
     [TestCase((ulong)0b1, "0000000000000000000000000000000000000000000000000000000000000001")]
     [TestCase((ulong)0b0001010100111000, "0000000000000000000000000000000000000000000000000001010100111000")]
diff --git a/Algorithms.Tests/Other/LuhnTests.cs b/Algorithms.Tests/Other/LuhnTests.cs
@@ -8,7 +8,6 @@ namespace Algorithms.Tests.Other;
 /// </summary>
 public class LuhnTests
 {
-    [Test]
     [TestCase("89014103211118510720")] // ICCID
     [TestCase("071052120")] // Social Security Code
     [TestCase("449125546588769")] // IMEI
@@ -25,7 +24,6 @@ public void ValidateTrue(string number)
         Assert.True(validate);
     }
 
-    [Test]
     [TestCase("89012104211118510720")] // ICCID
     [TestCase("021053120")] // Social Security Code
     [TestCase("449145545588969")] // IMEI
@@ -42,7 +40,6 @@ public void ValidateFalse(string number)
         Assert.False(validate);
     }
 
-    [Test]
     [TestCase("x9012104211118510720")] // ICCID
     [TestCase("0210x3120")] // Social Security Code
     [TestCase("44914554558896x")] // IMEI
diff --git a/Algorithms.Tests/Other/RGBHSVConversionTest.cs b/Algorithms.Tests/Other/RGBHSVConversionTest.cs
@@ -29,7 +29,6 @@ public static void ValueOutOfRange_ThrowsArgumentOutOfRangeException()
     }
 
     // expected RGB-values taken from https://www.rapidtables.com/convert/color/hsv-to-rgb.html
-    [Test]
     [TestCase(0, 0, 0, 0, 0, 0)]
     [TestCase(0, 0, 1, 255, 255, 255)]
     [TestCase(0, 1, 1, 255, 0, 0)]
@@ -55,7 +54,6 @@ public static void TestRgbOutput(
     }
 
     // Parameters of test-cases for TestRGBOutput reversed
-    [Test]
     [TestCase(0, 0, 0, 0, 0, 0)]
     [TestCase(255, 255, 255, 0, 0, 1)]
     [TestCase(255, 0, 0, 0, 1, 1)]
diff --git a/Algorithms.Tests/Problems/DynamicProgramming/LevenshteinDistance/LevenshteinDistanceTests.cs b/Algorithms.Tests/Problems/DynamicProgramming/LevenshteinDistance/LevenshteinDistanceTests.cs
@@ -5,7 +5,6 @@ namespace Algorithms.Tests.DynamicProgramming
 {
     public class LevenshteinDistanceTests
     {
-        [Test]
         [TestCase("kitten", "sitting", 3)]
         [TestCase("bob", "bond", 2)]
         [TestCase("algorithm", "logarithm", 3)]
diff --git a/Algorithms.Tests/Strings/GeneralStringAlgorithmsTests.cs b/Algorithms.Tests/Strings/GeneralStringAlgorithmsTests.cs
@@ -6,7 +6,6 @@ namespace Algorithms.Tests.Strings
 {
     public static class GeneralStringAlgorithmsTests
     {
-        [Test]
         [TestCase("Griffith", 'f', 2)]
         [TestCase("Randomwoooord", 'o', 4)]
         [TestCase("Control", 'C', 1)]
diff --git a/Algorithms.Tests/Strings/PalindromeTests.cs b/Algorithms.Tests/Strings/PalindromeTests.cs
@@ -5,7 +5,6 @@ namespace Algorithms.Tests.Strings
 {
     public static class PalindromeTests
     {
-        [Test]
         [TestCase("Anna")]
         [TestCase("A Santa at Nasa")]
         public static void TextIsPalindrome_TrueExpected(string text)
@@ -18,7 +17,6 @@ public static void TextIsPalindrome_TrueExpected(string text)
             Assert.True(isPalindrome);
         }
 
-        [Test]
         [TestCase("hallo")]
         [TestCase("Once upon a time")]
         public static void TextNotPalindrome_FalseExpected(string text)
diff --git a/Algorithms.Tests/Strings/Similarity/HammingDistanceTests.cs b/Algorithms.Tests/Strings/Similarity/HammingDistanceTests.cs
@@ -7,7 +7,6 @@ namespace Algorithms.Tests.Strings
 {
     public class HammingDistanceTests
     {
-        [Test]
         [TestCase("equal", "equal", 0)]
         [TestCase("dog", "dig", 1)]
         [TestCase("12345", "abcde", 5)]
diff --git a/Algorithms.Tests/Strings/Similarity/JaroSimilarityTests.cs b/Algorithms.Tests/Strings/Similarity/JaroSimilarityTests.cs
@@ -7,7 +7,6 @@ namespace Algorithms.Tests.Strings
 {
     public class JaroSimilarityTests
     {
-        [Test]
         [TestCase("equal", "equal", 1)]
         [TestCase("abc", "123", 0)]
         [TestCase("FAREMVIEL", "FARMVILLE", 0.88d)]
diff --git a/Algorithms.Tests/Strings/Similarity/JaroWinklerDistanceTests.cs b/Algorithms.Tests/Strings/Similarity/JaroWinklerDistanceTests.cs
@@ -7,7 +7,6 @@ namespace Algorithms.Tests.Strings
 {
     public class JaroWinklerDistanceTests
     {
-        [Test]
         [TestCase("equal", "equal", 0)]
         [TestCase("abc", "123", 1)]
         [TestCase("Winkler", "Welfare", 0.33)]
diff --git a/DataStructures.Tests/Graph/DirectedWeightedGraphTests.cs b/DataStructures.Tests/Graph/DirectedWeightedGraphTests.cs
diff --git a/DataStructures.Tests/Hashing/NumberTheory/PrimeNumberTests.cs b/DataStructures.Tests/Hashing/NumberTheory/PrimeNumberTests.cs
diff --git a/DataStructures.Tests/Heap/MinMaxHeapTests.cs b/DataStructures.Tests/Heap/MinMaxHeapTests.cs
diff --git a/DataStructures.Tests/ScapegoatTree/ScapegoatTreeNodeTests.cs b/DataStructures.Tests/ScapegoatTree/ScapegoatTreeNodeTests.cs
diff --git a/DataStructures.Tests/ScapegoatTree/ScapegoatTreeTests.cs b/DataStructures.Tests/ScapegoatTree/ScapegoatTreeTests.cs

Original file line number	Diff line number	Diff line change
`@@ -6,7 +6,6 @@ namespace Algorithms.Tests.Compressors;`
`6`	`6`
`7`	`7`	`public class BurrowsWheelerTransformTests`
`8`	`8`	`{`
`9`		`- [Test]`
`10`	`9`	`[TestCase("banana", "nnbaaa", 3)]`
`11`	`10`	`[TestCase("SIX.MIXED.PIXIES.SIFT.SIXTY.PIXIE.DUST.BOXES", "TEXYDST.E.IXIXIXXSSMPPS.B..E.S.EUSFXDIIOIIIT", 29)]`
`12`	`11`	`[TestCase("", "", 0)]`
`@@ -20,7 +19,6 @@ public void Encode(string input, string expectedString, int expectedIndex)`
`20`	`19`	`Assert.AreEqual(expectedIndex, index);`
`21`	`20`	`}`
`22`	`21`
`23`		`- [Test]`
`24`	`22`	`[TestCase("nnbaaa", 3, "banana")]`
`25`	`23`	`[TestCase("TEXYDST.E.IXIXIXXSSMPPS.B..E.S.EUSFXDIIOIIIT", 29, "SIX.MIXED.PIXIES.SIFT.SIXTY.PIXIE.DUST.BOXES")]`
`26`	`24`	`[TestCase("", 0, "")]`
Original file line number	Diff line number	Diff line change
`@@ -8,7 +8,6 @@ namespace Algorithms.Tests.Compressors;`
`8`	`8`
`9`	`9`	`public static class HuffmanCompressorTests`
`10`	`10`	`{`
`11`		`- [Test]`
`12`	`11`	`[TestCase("This is a string", "101010110111011101110111100011111010010010010011000")]`
`13`	`12`	`[TestCase("Hello", "1101110010")]`
`14`	`13`	`[TestCase("dddddddddd", "1111111111")]`
Original file line number	Diff line number	Diff line change
`@@ -7,7 +7,6 @@ namespace Algorithms.Tests.Compressors;`
`7`	`7`
`8`	`8`	`public static class ShannonFanoCompressorTests`
`9`	`9`	`{`
`10`		`- [Test]`
`11`	`10`	`[TestCase("dddddddddd", "1111111111")]`
`12`	`11`	`[TestCase("a", "1")]`
`13`	`12`	`[TestCase("", "")]`
Original file line number	Diff line number	Diff line change
`@@ -26,7 +26,6 @@ public static void DecodedStringIsTheSame([Random(100)] uint key)`
`26`	`26`	`Assert.AreEqual(message, decoded);`
`27`	`27`	`}`
`28`	`28`
`29`		`- [Test]`
`30`	`29`	`[TestCase("00001111", (uint)0x12345678)]`
`31`	`30`	`[TestCase("00001111222233334444555566667", (uint)0x12345678)]`
`32`	`31`	`[TestCase("000011112222333344445555666677", (uint)0x12345678)]`
Original file line number	Diff line number	Diff line change
`@@ -39,7 +39,6 @@ public static void EmptyArrayForNullRoot()`
`39`	`39`	`Assert.IsEmpty(levelOrder);`
`40`	`40`	`}`
`41`	`41`
`42`		`- [Test]`
`43`	`42`	`[TestCase(new [] {7, 9, 5})]`
`44`	`43`	`[TestCase(new [] { 7, 13, 11, 15, 14, 4, 5, 16, 2 })]`
`45`	`44`	`public static void IncorrectLevelOrderTraversal(int[] insertion)`
Original file line number	Diff line number	Diff line change
`@@ -6,7 +6,6 @@ namespace Algorithms.Tests.ModularArithmetic;`
`6`	`6`
`7`	`7`	`public static class ExtendedEuclideanAlgorithmTest`
`8`	`8`	`{`
`9`		`- [Test]`
`10`	`9`	`[TestCase(240, 46, 2, -9, 47)]`
`11`	`10`	`[TestCase(46, 240, 2, 47, -9)]`
`12`	`11`	`[TestCase(2, 3, 1, -1, 1)]`
`@@ -29,7 +28,6 @@ public static void TestCompute(long a, long b, long expectedGCD, long expectedBe`
`29`	`28`	`Assert.AreEqual(expectedBezoutOfB, eeaResult.bezoutB);`
`30`	`29`	`}`
`31`	`30`
`32`		`- [Test]`
`33`	`31`	`[TestCase(240, 46, 2, -9, 47)]`
`34`	`32`	`[TestCase(46, 240, 2, 47, -9)]`
`35`	`33`	`[TestCase(2, 3, 1, -1, 1)]`
Original file line number	Diff line number	Diff line change
`@@ -7,7 +7,6 @@ namespace Algorithms.Tests.Numeric;`
`7`	`7`
`8`	`8`	`public static class AliquotSumCalculatorTests`
`9`	`9`	`{`
`10`		`- [Test]`
`11`	`10`	`[TestCase(1, 0)]`
`12`	`11`	`[TestCase(3, 1)]`
`13`	`12`	`[TestCase(25, 6)]`
`@@ -23,7 +22,6 @@ public static void CalculateSum_SumIsCorrect(int number, int expectedSum)`
`23`	`22`	`result.Should().Be(expectedSum);`
`24`	`23`	`}`
`25`	`24`
`26`		`- [Test]`
`27`	`25`	`[TestCase(-2)]`
`28`	`26`	`public static void CalculateSum_NegativeInput_ExceptionIsThrown(int number)`
`29`	`27`	`{`