Project AlgorithmsTests

Algorithms.Tests/Compressors/BurrowsWheelerTransformTests.cs

@@ -1,50 +1,49 @@
-using Algorithms.DataCompression;
+using Algorithms.DataCompression;
 using NUnit.Framework;
 using NUnit.Framework.Internal;
 
-namespace Algorithms.Tests.Compressors
+namespace Algorithms.Tests.Compressors;
+
+public class BurrowsWheelerTransformTests
 {
- 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)]
+ public void Encode(string input, string expectedString, int expectedIndex)
  {
- [Test]
- [TestCase("banana", "nnbaaa", 3)]
- [TestCase("SIX.MIXED.PIXIES.SIFT.SIXTY.PIXIE.DUST.BOXES", "TEXYDST.E.IXIXIXXSSMPPS.B..E.S.EUSFXDIIOIIIT", 29)]
- [TestCase("", "", 0)]
- public void Encode(string input, string expectedString, int expectedIndex)
- {
- var bwt = new BurrowsWheelerTransform();
-
- var (encoded, index) = bwt.Encode(input);
-
- Assert.AreEqual(expectedString, encoded);
- 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, "")]
- public void Decode(string encoded, int index, string expected)
- {
- var bwt = new BurrowsWheelerTransform();
-
- var result = bwt.Decode(encoded, index);
-
- Assert.AreEqual(expected, result);
- }
-
- [Test]
- [Repeat(100)]
- public void RandomEncodeDecode()
- {
- var bwt = new BurrowsWheelerTransform();
- var random = new Randomizer();
- var inputString = random.GetString();
-
- var (encoded, index) = bwt.Encode(inputString);
- var result = bwt.Decode(encoded, index);
-
- Assert.AreEqual(inputString, result);
- }
+ var bwt = new BurrowsWheelerTransform();
+
+ var (encoded, index) = bwt.Encode(input);
+
+ Assert.AreEqual(expectedString, encoded);
+ 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, "")]
+ public void Decode(string encoded, int index, string expected)
+ {
+ var bwt = new BurrowsWheelerTransform();
+
+ var result = bwt.Decode(encoded, index);
+
+ Assert.AreEqual(expected, result);
+ }
+
+ [Test]
+ [Repeat(100)]
+ public void RandomEncodeDecode()
+ {
+ var bwt = new BurrowsWheelerTransform();
+ var random = new Randomizer();
+ var inputString = random.GetString();
+
+ var (encoded, index) = bwt.Encode(inputString);
+ var result = bwt.Decode(encoded, index);
+
+ Assert.AreEqual(inputString, result);
  }
 }

Algorithms.Tests/Compressors/HuffmanCompressorTests.cs

@@ -1,63 +1,62 @@
-using Algorithms.DataCompression;
+using Algorithms.DataCompression;
 using Algorithms.Sorters.Comparison;
 using FluentAssertions;
 using NUnit.Framework;
 using NUnit.Framework.Internal;
 
-namespace Algorithms.Tests.Compressors
+namespace Algorithms.Tests.Compressors;
+
+public static class HuffmanCompressorTests
 {
- public static class HuffmanCompressorTests
+ [Test]
+ [TestCase("This is a string", "101010110111011101110111100011111010010010010011000")]
+ [TestCase("Hello", "1101110010")]
+ [TestCase("dddddddddd", "1111111111")]
+ [TestCase("a", "1")]
+ [TestCase("", "")]
+ public static void CompressingPhrase(string uncompressedText, string expectedCompressedText)
+ {
+ //Arrange
+ var sorter = new BubbleSorter<HuffmanCompressor.ListNode>();
+ var translator = new Translator();
+ var huffman = new HuffmanCompressor(sorter, translator);
+
+ //Act
+ var (compressedText, decompressionKeys) = huffman.Compress(uncompressedText);
+ var decompressedText = translator.Translate(compressedText, decompressionKeys);
+
+ //Assert
+ Assert.AreEqual(expectedCompressedText, compressedText);
+ Assert.AreEqual(uncompressedText, decompressedText);
+ }
+
+ [Test]
+ public static void DecompressedTextTheSameAsOriginal(
+ [Random(0, 1000, 100, Distinct = true)]
+ int length)
  {
- [Test]
- [TestCase("This is a string", "101010110111011101110111100011111010010010010011000")]
- [TestCase("Hello", "1101110010")]
- [TestCase("dddddddddd", "1111111111")]
- [TestCase("a", "1")]
- [TestCase("", "")]
- public static void CompressingPhrase(string uncompressedText, string expectedCompressedText)
- {
- //Arrange
- var sorter = new BubbleSorter<HuffmanCompressor.ListNode>();
- var translator = new Translator();
- var huffman = new HuffmanCompressor(sorter, translator);
-
- //Act
- var (compressedText, decompressionKeys) = huffman.Compress(uncompressedText);
- var decompressedText = translator.Translate(compressedText, decompressionKeys);
-
- //Assert
- Assert.AreEqual(expectedCompressedText, compressedText);
- Assert.AreEqual(uncompressedText, decompressedText);
- }
-
- [Test]
- public static void DecompressedTextTheSameAsOriginal(
- [Random(0, 1000, 100, Distinct = true)]
- int length)
- {
- //Arrange
- var sorter = new BubbleSorter<HuffmanCompressor.ListNode>();
- var translator = new Translator();
- var huffman = new HuffmanCompressor(sorter, translator);
- var text = Randomizer.CreateRandomizer().GetString(length);
-
- //Act
- var (compressedText, decompressionKeys) = huffman.Compress(text);
- var decompressedText = translator.Translate(compressedText, decompressionKeys);
-
- //Assert
- Assert.AreEqual(text, decompressedText);
- }
-
- [Test]
- public static void ListNodeComparer_NullIsUnordered()
- {
- var comparer = new HuffmanCompressor.ListNodeComparer();
- var node = new HuffmanCompressor.ListNode('a', 0.1);
-
- comparer.Compare(node, null).Should().Be(0);
- comparer.Compare(null, node).Should().Be(0);
- comparer.Compare(null, null).Should().Be(0);
- }
+ //Arrange
+ var sorter = new BubbleSorter<HuffmanCompressor.ListNode>();
+ var translator = new Translator();
+ var huffman = new HuffmanCompressor(sorter, translator);
+ var text = Randomizer.CreateRandomizer().GetString(length);
+
+ //Act
+ var (compressedText, decompressionKeys) = huffman.Compress(text);
+ var decompressedText = translator.Translate(compressedText, decompressionKeys);
+
+ //Assert
+ Assert.AreEqual(text, decompressedText);
+ }
+
+ [Test]
+ public static void ListNodeComparer_NullIsUnordered()
+ {
+ var comparer = new HuffmanCompressor.ListNodeComparer();
+ var node = new HuffmanCompressor.ListNode('a', 0.1);
+
+ comparer.Compare(node, null).Should().Be(0);
+ comparer.Compare(null, node).Should().Be(0);
+ comparer.Compare(null, null).Should().Be(0);
  }
 }

Algorithms.Tests/Compressors/ShannonFanoCompressorTests.cs

@@ -1,47 +1,46 @@
-using Algorithms.DataCompression;
+using Algorithms.DataCompression;
 using Algorithms.Knapsack;
 using NUnit.Framework;
 using NUnit.Framework.Internal;
 
-namespace Algorithms.Tests.Compressors
+namespace Algorithms.Tests.Compressors;
+
+public static class ShannonFanoCompressorTests
 {
- public static class ShannonFanoCompressorTests
+ [Test]
+ [TestCase("dddddddddd", "1111111111")]
+ [TestCase("a", "1")]
+ [TestCase("", "")]
+ public static void CompressingPhrase(string uncompressedText, string expectedCompressedText)
  {
- [Test]
- [TestCase("dddddddddd", "1111111111")]
- [TestCase("a", "1")]
- [TestCase("", "")]
- public static void CompressingPhrase(string uncompressedText, string expectedCompressedText)
- {
- //Arrange
- var solver = new NaiveKnapsackSolver<(char, double)>();
- var translator = new Translator();
- var shannonFanoCompressor = new ShannonFanoCompressor(solver, translator);
+ //Arrange
+ var solver = new NaiveKnapsackSolver<(char, double)>();
+ var translator = new Translator();
+ var shannonFanoCompressor = new ShannonFanoCompressor(solver, translator);
 
-  //Act
-  var (compressedText, decompressionKeys) = shannonFanoCompressor.Compress(uncompressedText);
-  var decompressedText = translator.Translate(compressedText, decompressionKeys);
+ //Act
+ var (compressedText, decompressionKeys) = shannonFanoCompressor.Compress(uncompressedText);
+ var decompressedText = translator.Translate(compressedText, decompressionKeys);
 
-  //Assert
-  Assert.AreEqual(expectedCompressedText, compressedText);
-  Assert.AreEqual(uncompressedText, decompressedText);
-  }
+ //Assert
+ Assert.AreEqual(expectedCompressedText, compressedText);
+ Assert.AreEqual(uncompressedText, decompressedText);
+ }
 
-  [Test]
-  public static void DecompressedTextTheSameAsOriginal([Random(0, 1000, 100)] int length)
-  {
-  //Arrange
-  var solver = new NaiveKnapsackSolver<(char, double)>();
-  var translator = new Translator();
-  var shannonFanoCompressor = new ShannonFanoCompressor(solver, translator);
-  var text = Randomizer.CreateRandomizer().GetString(length);
+ [Test]
+ public static void DecompressedTextTheSameAsOriginal([Random(0, 1000, 100)] int length)
+ {
+ //Arrange
+ var solver = new NaiveKnapsackSolver<(char, double)>();
+ var translator = new Translator();
+ var shannonFanoCompressor = new ShannonFanoCompressor(solver, translator);
+ var text = Randomizer.CreateRandomizer().GetString(length);
 
-  //Act
-  var (compressedText, decompressionKeys) = shannonFanoCompressor.Compress(text);
-  var decompressedText = translator.Translate(compressedText, decompressionKeys);
+ //Act
+ var (compressedText, decompressionKeys) = shannonFanoCompressor.Compress(text);
+ var decompressedText = translator.Translate(compressedText, decompressionKeys);
 
- //Assert
- Assert.AreEqual(text, decompressedText);
- }
+ //Assert
+ Assert.AreEqual(text, decompressedText);
  }
 }

Algorithms.Tests/Compressors/TranslatorTests.cs

@@ -1,29 +1,28 @@
-using System.Collections.Generic;
+using System.Collections.Generic;
 using Algorithms.DataCompression;
 using NUnit.Framework;
 
-namespace Algorithms.Tests.Compressors
+namespace Algorithms.Tests.Compressors;
+
+public static class TranslatorTests
 {
- public static class TranslatorTests
+ [Test]
+ public static void TranslateCorrectly()
  {
- [Test]
- public static void TranslateCorrectly()
+ // Arrange
+ var translator = new Translator();
+ var dict = new Dictionary<string, string>
  {
- // Arrange
- var translator = new Translator();
- var dict = new Dictionary<string, string>
- {
- { "Hey", "Good day" },
- { " ", " " },
- { "man", "sir" },
- { "!", "." },
- };
+ { "Hey", "Good day" },
+ { " ", " " },
+ { "man", "sir" },
+ { "!", "." },
+ };
 
-  // Act
-  var translatedText = translator.Translate("Hey man!", dict);
+ // Act
+ var translatedText = translator.Translate("Hey man!", dict);
 
- // Assert
- Assert.AreEqual("Good day sir.", translatedText);
- }
+ // Assert
+ Assert.AreEqual("Good day sir.", translatedText);
  }
 }

Algorithms.Tests/Encoders/CaesarEncoderTests.cs

@@ -1,25 +1,24 @@
-using Algorithms.Encoders;
+using Algorithms.Encoders;
 using NUnit.Framework;
 using NUnit.Framework.Internal;
 
-namespace Algorithms.Tests.Encoders
+namespace Algorithms.Tests.Encoders;
+
+public static class CaesarEncoderTests
 {
- public static class CaesarEncoderTests
+ [Test]
+ public static void DecodedStringIsTheSame([Random(100)] int key)
  {
- [Test]
- public static void DecodedStringIsTheSame([Random(100)] int key)
- {
- // Arrange
- var encoder = new CaesarEncoder();
- var random = new Randomizer();
- var message = random.GetString();
+ // Arrange
+ var encoder = new CaesarEncoder();
+ var random = new Randomizer();
+ var message = random.GetString();
 
-  // Act
-  var encoded = encoder.Encode(message, key);
-  var decoded = encoder.Decode(encoded, key);
+ // Act
+ var encoded = encoder.Encode(message, key);
+ var decoded = encoder.Decode(encoded, key);
 
- // Assert
- Assert.AreEqual(message, decoded);
- }
+ // Assert
+ Assert.AreEqual(message, decoded);
  }
 }