Update encoders (#41)

* Update encoders * Update README to include updated encoders * Update unit tests for updated encoders
Thomas-Shephard · Apr 16, 2024 · 33cfd23 · 33cfd23
1 parent 1fb8a31
commit 33cfd23
Show file tree

Hide file tree

Showing 18 changed files with 224 additions and 185 deletions.
diff --git a/IOUtils.Tests/EncoderTests/Base10Tests.cs → ...sts/DataTests/EncoderTests/Base10Tests.cs b/IOUtils.Tests/EncoderTests/Base10Tests.cs → ...sts/DataTests/EncoderTests/Base10Tests.cs
@@ -1,15 +1,16 @@
-using IOUtils.Encoders;
+using IOUtils.Data;
+using IOUtils.Tests.EncoderTests;
 using NUnit.Framework;
 
-namespace IOUtils.Tests.EncoderTests;
+namespace IOUtils.Tests.DataTests.EncoderTests;
 
 public class Base10Tests {
     private const string TestEncodedValue = "1415934836";
     private const string HelloWorldEncodedValue = "5735816763073854918203775149089";
 
     [Test]
     public void Base10_Encode_Test_ReturnsEncodedString() {
-        string actual = Base10Encoder.Encode(TestRawValues.TestBytes);
+        string actual = Encoder.Base10.Encode(TestRawValues.TestBytes);
 
         Assert.That(actual, Is.EqualTo(TestEncodedValue));
     }
@@ -18,14 +19,14 @@ public void Base10_Encode_Test_ReturnsEncodedString() {
     public void Base10_Decode_Test_ReturnsDecodedBytes() {
         byte[] expected = TestRawValues.TestBytes;
 
-        byte[] actual = Base10Encoder.Decode(TestEncodedValue);
+        byte[] actual = Encoder.Base10.Decode(TestEncodedValue);
 
         Assert.That(actual, Is.EqualTo(expected));
     }
 
     [Test]
     public void Base10_Encode_HelloWorld_ReturnsEncodedString() {
-        string actual = Base10Encoder.Encode(TestRawValues.HelloWorldBytes);
+        string actual = Encoder.Base10.Encode(TestRawValues.HelloWorldBytes);
 
         Assert.That(actual, Is.EqualTo(HelloWorldEncodedValue));
     }
@@ -34,14 +35,14 @@ public void Base10_Encode_HelloWorld_ReturnsEncodedString() {
     public void Base10_Decode_HelloWorld_ReturnsDecodedBytes() {
         byte[] expected = TestRawValues.HelloWorldBytes;
 
-        byte[] actual = Base10Encoder.Decode(HelloWorldEncodedValue);
+        byte[] actual = Encoder.Base10.Decode(HelloWorldEncodedValue);
 
         Assert.That(actual, Is.EqualTo(expected));
     }
 
     [Test]
     public void Base10_Encode_EmptyArray_ReturnsEmptyString() {
-        string actual = Base10Encoder.Encode(TestRawValues.EmptyBytes);
+        string actual = Encoder.Base10.Encode(TestRawValues.EmptyBytes);
 
         Assert.That(actual, Is.Empty);
     }
@@ -50,13 +51,13 @@ public void Base10_Encode_EmptyArray_ReturnsEmptyString() {
     public void Base10_Decode_EmptyString_ReturnsEmptyArray() {
         byte[] expected = TestRawValues.EmptyBytes;
 
-        byte[] actual = Base10Encoder.Decode(string.Empty);
+        byte[] actual = Encoder.Base10.Decode(string.Empty);
 
         Assert.That(actual, Is.EqualTo(expected));
     }
 
     [Test]
     public void Base10_Decode_InvalidCharacter_ThrowsFormatException() {
-        Assert.Throws<FormatException>(() => Base10Encoder.Decode("1379A"));
+        Assert.Throws<ArgumentException>(() => Encoder.Base10.Decode("1379A"));
     }
 }
diff --git a/IOUtils.Tests/EncoderTests/Base16Tests.cs → ...sts/DataTests/EncoderTests/Base16Tests.cs b/IOUtils.Tests/EncoderTests/Base16Tests.cs → ...sts/DataTests/EncoderTests/Base16Tests.cs
@@ -1,15 +1,16 @@
-using IOUtils.Encoders;
+using IOUtils.Data;
+using IOUtils.Tests.EncoderTests;
 using NUnit.Framework;
 
-namespace IOUtils.Tests.EncoderTests;
+namespace IOUtils.Tests.DataTests.EncoderTests;
 
 public class Base16Tests {
     private const string TestEncodedValue = "54657374";
     private const string HelloWorldEncodedValue = "48656C6C6F2C20576F726C6421";
 
     [Test]
     public void Base16_Encode_Test_ReturnsEncodedString() {
-        string actual = Base16Encoder.Encode(TestRawValues.TestBytes);
+        string actual = Encoder.Base16.Encode(TestRawValues.TestBytes);
 
         Assert.That(actual, Is.EqualTo(TestEncodedValue));
     }
@@ -18,14 +19,14 @@ public void Base16_Encode_Test_ReturnsEncodedString() {
     public void Base16_Decode_Test_ReturnsDecodedBytes() {
         byte[] expected = TestRawValues.TestBytes;
 
-        byte[] actual = Base16Encoder.Decode(TestEncodedValue);
+        byte[] actual = Encoder.Base16.Decode(TestEncodedValue);
 
         Assert.That(actual, Is.EqualTo(expected));
     }
 
     [Test]
     public void Base16_Encode_HelloWorld_ReturnsEncodedString() {
-        string actual = Base16Encoder.Encode(TestRawValues.HelloWorldBytes);
+        string actual = Encoder.Base16.Encode(TestRawValues.HelloWorldBytes);
 
         Assert.That(actual, Is.EqualTo(HelloWorldEncodedValue));
     }
@@ -34,14 +35,14 @@ public void Base16_Encode_HelloWorld_ReturnsEncodedString() {
     public void Base16_Decode_HelloWorld_ReturnsDecodedBytes() {
         byte[] expected = TestRawValues.HelloWorldBytes;
 
-        byte[] actual = Base16Encoder.Decode(HelloWorldEncodedValue);
+        byte[] actual = Encoder.Base16.Decode(HelloWorldEncodedValue);
 
         Assert.That(actual, Is.EqualTo(expected));
     }
 
     [Test]
     public void Base16_Encode_EmptyArray_ReturnsEmptyString() {
-        string actual = Base16Encoder.Encode(TestRawValues.EmptyBytes);
+        string actual = Encoder.Base16.Encode(TestRawValues.EmptyBytes);
 
         Assert.That(actual, Is.Empty);
     }
@@ -50,13 +51,13 @@ public void Base16_Encode_EmptyArray_ReturnsEmptyString() {
     public void Base16_Decode_EmptyString_ReturnsEmptyArray() {
         byte[] expected = TestRawValues.EmptyBytes;
 
-        byte[] actual = Base16Encoder.Decode(string.Empty);
+        byte[] actual = Encoder.Base16.Decode(string.Empty);
 
         Assert.That(actual, Is.EqualTo(expected));
     }
 
     [Test]
     public void Base16_Decode_InvalidCharacter_ThrowsFormatException() {
-        Assert.Throws<FormatException>(() => Base16Encoder.Decode("1379ADG"));
+        Assert.Throws<ArgumentException>(() => Encoder.Base16.Decode("1379ADG"));
     }
 }
diff --git a/IOUtils.Tests/EncoderTests/Base2Tests.cs → ...ests/DataTests/EncoderTests/Base2Tests.cs b/IOUtils.Tests/EncoderTests/Base2Tests.cs → ...ests/DataTests/EncoderTests/Base2Tests.cs
@@ -1,15 +1,16 @@
-using IOUtils.Encoders;
+using IOUtils.Data;
+using IOUtils.Tests.EncoderTests;
 using NUnit.Framework;
 
-namespace IOUtils.Tests.EncoderTests;
+namespace IOUtils.Tests.DataTests.EncoderTests;
 
 public class Base2Tests {
     private const string TestEncodedValue = "1010100011001010111001101110100";
     private const string HelloWorldEncodedValue = "1001000011001010110110001101100011011110010110000100000010101110110111101110010011011000110010000100001";
 
     [Test]
     public void Base2_Encode_Test_ReturnsEncodedString() {
-        string actual = Base2Encoder.Encode(TestRawValues.TestBytes);
+        string actual = Encoder.Base2.Encode(TestRawValues.TestBytes);
 
         Assert.That(actual, Is.EqualTo(TestEncodedValue));
     }
@@ -18,14 +19,14 @@ public void Base2_Encode_Test_ReturnsEncodedString() {
     public void Base2_Decode_Test_ReturnsDecodedBytes() {
         byte[] expected = TestRawValues.TestBytes;
 
-        byte[] actual = Base2Encoder.Decode(TestEncodedValue);
+        byte[] actual = Encoder.Base2.Decode(TestEncodedValue);
 
         Assert.That(actual, Is.EqualTo(expected));
     }
 
     [Test]
     public void Base2_Encode_HelloWorld_ReturnsEncodedString() {
-        string actual = Base2Encoder.Encode(TestRawValues.HelloWorldBytes);
+        string actual = Encoder.Base2.Encode(TestRawValues.HelloWorldBytes);
 
         Assert.That(actual, Is.EqualTo(HelloWorldEncodedValue));
     }
@@ -34,14 +35,14 @@ public void Base2_Encode_HelloWorld_ReturnsEncodedString() {
     public void Base2_Decode_HelloWorld_ReturnsDecodedBytes() {
         byte[] expected = TestRawValues.HelloWorldBytes;
 
-        byte[] actual = Base2Encoder.Decode(HelloWorldEncodedValue);
+        byte[] actual = Encoder.Base2.Decode(HelloWorldEncodedValue);
 
         Assert.That(actual, Is.EqualTo(expected));
     }
 
     [Test]
     public void Base2_Encode_EmptyArray_ReturnsEmptyString() {
-        string actual = Base2Encoder.Encode(TestRawValues.EmptyBytes);
+        string actual = Encoder.Base2.Encode(TestRawValues.EmptyBytes);
 
         Assert.That(actual, Is.Empty);
     }
@@ -50,13 +51,13 @@ public void Base2_Encode_EmptyArray_ReturnsEmptyString() {
     public void Base2_Decode_EmptyString_ReturnsEmptyArray() {
         byte[] expected = TestRawValues.EmptyBytes;
 
-        byte[] actual = Base2Encoder.Decode(string.Empty);
+        byte[] actual = Encoder.Base2.Decode(string.Empty);
 
         Assert.That(actual, Is.EqualTo(expected));
     }
 
     [Test]
     public void Base2_Decode_InvalidCharacter_ThrowsFormatException() {
-        Assert.Throws<FormatException>(() => Base2Encoder.Decode("10X"));
+        Assert.Throws<ArgumentException>(() => Encoder.Base2.Decode("10X"));
     }
 }
diff --git a/IOUtils.Tests/EncoderTests/Base36Tests.cs → ...sts/DataTests/EncoderTests/Base36Tests.cs b/IOUtils.Tests/EncoderTests/Base36Tests.cs → ...sts/DataTests/EncoderTests/Base36Tests.cs
@@ -1,15 +1,16 @@
-using IOUtils.Encoders;
+using IOUtils.Data;
+using IOUtils.Tests.EncoderTests;
 using NUnit.Framework;
 
-namespace IOUtils.Tests.EncoderTests;
+namespace IOUtils.Tests.DataTests.EncoderTests;
 
 public class Base36Tests {
     private const string TestEncodedValue = "NF0EB8";
     private const string HelloWorldEncodedValue = "FG3H7VQW7EEN6JWWNZMP";
 
     [Test]
     public void Base36_Encode_Test_ReturnsEncodedString() {
-        string actual = Base36Encoder.Encode(TestRawValues.TestBytes);
+        string actual = Encoder.Base36.Encode(TestRawValues.TestBytes);
 
         Assert.That(actual, Is.EqualTo(TestEncodedValue));
     }
@@ -18,14 +19,14 @@ public void Base36_Encode_Test_ReturnsEncodedString() {
     public void Base36_Decode_Test_ReturnsDecodedBytes() {
         byte[] expected = TestRawValues.TestBytes;
 
-        byte[] actual = Base36Encoder.Decode(TestEncodedValue);
+        byte[] actual = Encoder.Base36.Decode(TestEncodedValue);
 
         Assert.That(actual, Is.EqualTo(expected));
     }
 
     [Test]
     public void Base36_Encode_HelloWorld_ReturnsEncodedString() {
-        string actual = Base36Encoder.Encode(TestRawValues.HelloWorldBytes);
+        string actual = Encoder.Base36.Encode(TestRawValues.HelloWorldBytes);
 
         Assert.That(actual, Is.EqualTo(HelloWorldEncodedValue));
     }
@@ -34,14 +35,14 @@ public void Base36_Encode_HelloWorld_ReturnsEncodedString() {
     public void Base36_Decode_HelloWorld_ReturnsDecodedBytes() {
         byte[] expected = TestRawValues.HelloWorldBytes;
 
-        byte[] actual = Base36Encoder.Decode(HelloWorldEncodedValue);
+        byte[] actual = Encoder.Base36.Decode(HelloWorldEncodedValue);
 
         Assert.That(actual, Is.EqualTo(expected));
     }
 
     [Test]
     public void Base36_Encode_EmptyArray_ReturnsEmptyString() {
-        string actual = Base36Encoder.Encode(TestRawValues.EmptyBytes);
+        string actual = Encoder.Base36.Encode(TestRawValues.EmptyBytes);
 
         Assert.That(actual, Is.Empty);
     }
@@ -50,13 +51,13 @@ public void Base36_Encode_EmptyArray_ReturnsEmptyString() {
     public void Base36_Decode_EmptyString_ReturnsEmptyArray() {
         byte[] expected = TestRawValues.EmptyBytes;
 
-        byte[] actual = Base36Encoder.Decode(string.Empty);
+        byte[] actual = Encoder.Base36.Decode(string.Empty);
 
         Assert.That(actual, Is.EqualTo(expected));
     }
 
     [Test]
     public void Base36_Decode_InvalidCharacter_ThrowsFormatException() {
-        Assert.Throws<FormatException>(() => Base36Encoder.Decode("0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ!"));
+        Assert.Throws<ArgumentException>(() => Encoder.Base36.Decode("0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ!"));
     }
 }
diff --git a/IOUtils.Tests/DataTests/EncoderTests/Base62Tests.cs b/IOUtils.Tests/DataTests/EncoderTests/Base62Tests.cs
@@ -0,0 +1,63 @@
+using IOUtils.Data;
+using IOUtils.Tests.EncoderTests;
+using NUnit.Framework;
+
+namespace IOUtils.Tests.DataTests.EncoderTests;
+
+public class Base62Tests {
+    private const string TestEncodedValue = "1Xp7Ke";
+    private const string HelloWorldEncodedValue = "1wJfrzvdbtXUOlUjUf";
+
+    [Test]
+    public void Base62_Encode_Test_ReturnsEncodedString() {
+        string actual = Encoder.Base62.Encode(TestRawValues.TestBytes);
+
+        Assert.That(actual, Is.EqualTo(TestEncodedValue));
+    }
+
+    [Test]
+    public void Base62_Decode_Test_ReturnsDecodedBytes() {
+        byte[] expected = TestRawValues.TestBytes;
+
+        byte[] actual = Encoder.Base62.Decode(TestEncodedValue);
+
+        Assert.That(actual, Is.EqualTo(expected));
+    }
+
+    [Test]
+    public void Base62_Encode_HelloWorld_ReturnsEncodedString() {
+        string actual = Encoder.Base62.Encode(TestRawValues.HelloWorldBytes);
+
+        Assert.That(actual, Is.EqualTo(HelloWorldEncodedValue));
+    }
+
+    [Test]
+    public void Base62_Decode_HelloWorld_ReturnsDecodedBytes() {
+        byte[] expected = TestRawValues.HelloWorldBytes;
+
+        byte[] actual = Encoder.Base62.Decode(HelloWorldEncodedValue);
+
+        Assert.That(actual, Is.EqualTo(expected));
+    }
+
+    [Test]
+    public void Base62_Encode_EmptyArray_ReturnsEmptyString() {
+        string actual = Encoder.Base62.Encode(TestRawValues.EmptyBytes);
+
+        Assert.That(actual, Is.Empty);
+    }
+
+    [Test]
+    public void Base62_Decode_EmptyString_ReturnsEmptyArray() {
+        byte[] expected = TestRawValues.EmptyBytes;
+
+        byte[] actual = Encoder.Base62.Decode(string.Empty);
+
+        Assert.That(actual, Is.EqualTo(expected));
+    }
+
+    [Test]
+    public void Base62_Decode_InvalidCharacter_ThrowsFormatException() {
+        Assert.Throws<ArgumentException>(() => Encoder.Base62.Decode("0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ-_"));
+    }
+}