Restructures Duid and DuidTests classes into multiple concern based class partials (#21)

Refactor Duid and DuidTests Classes

- Split Duid class into multiple concern-based partial classes.
- Split DuidTests class into multiple concern-based partial classes.
- Updated to xUnit v3 and utilized `TheoryData`.
- Updated package dependencies.
- Implemented proper serialization of `Duid` for xUnit tests using IXunitSerializer.

Author: rheone

src/NetDuid.Tests/Duid.FactoryTests.cs

@@ -0,0 +1,157 @@
+using System;
+using Xunit;
+
+namespace NetDuid.Tests
+{
+    public partial class DuidTests
+    {
+        #region TryParse(string, Duid)
+
+        public static TheoryData<byte[], string> Parse_String_Success_Test_TestCases()
+        {
+            var theoryData = new TheoryData<byte[], string>();
+
+            // legal delimiters
+            var delimiters = new string[] { ":", "-", " ", string.Empty };
+
+            // DUIDs should be between 3 and 130 bytes inclusively
+            for (var byteCount = 3; byteCount <= 130; byteCount++)
+            {
+                var duidBytes = StaticTestData.GenerateBytes(byteCount, byteCount); // seed random with the number of bytes so byte arrays aren't similar
+
+                foreach (var delimiter in delimiters)
+                {
+                    // upper case version
+                    var upperCase = duidBytes.BytesAsString(delimiter);
+                    AddTestCase(duidBytes, upperCase);
+
+                    // lower case version
+                    var lowerCase = upperCase.ToLowerInvariant();
+                    AddTestCase(duidBytes, lowerCase);
+
+                    if (delimiter != string.Empty)
+                    {
+                        // delimited strings do not require a leading 0
+                        var delimitedUpperCase = duidBytes.BytesAsStringNoLeadingZero(delimiter);
+
+                        AddTestCase(duidBytes, delimitedUpperCase);
+                        AddTestCase(duidBytes, delimitedUpperCase.ToLowerInvariant());
+                    }
+                }
+            }
+
+            return theoryData;
+
+            void AddTestCase(byte[] expectedBytes, string inputString)
+            {
+                theoryData.Add(expectedBytes, inputString);
+            }
+        }
+
+        [Theory]
+        [MemberData(nameof(Parse_String_Success_Test_TestCases))]
+        public void TryParse_String_Success_Test(byte[] expectedBytes, string inputString)
+        {
+            // Arrange
+            // Act
+            var success = Duid.TryParse(inputString, out var duid);
+
+            // Assert
+            Assert.True(success, "parse failed");
+            Assert.NotNull(duid);
+
+            Assert.IsType<Duid>(duid);
+            Assert.Equal(expectedBytes, duid.GetBytes());
+        }
+
+        public static TheoryData<string> Parse_String_Invalid_Test_TestCases()
+        {
+            var theoryData = new TheoryData<string>();
+
+            AddTestCase(null);
+            AddTestCase(string.Empty);
+            AddTestCase("potato");
+
+            // invalid lengths
+            foreach (var byteLength in new[] { 1, 2, 131, 200 })
+            {
+                AddTestCase(StaticTestData.GenerateBytes(byteLength).BytesAsString());
+            }
+
+            return theoryData;
+
+            void AddTestCase(string invalidDuidString)
+            {
+                theoryData.Add(invalidDuidString);
+            }
+        }
+
+        [Theory]
+        [MemberData(nameof(Parse_String_Invalid_Test_TestCases))]
+        public void Try_Parse_String_Invalid_Test(string inputString)
+        {
+            // Arrange
+            // Act
+            var success = Duid.TryParse(inputString, out var duid);
+
+            // Assert
+            Assert.False(success, "unexpectedly succeeded");
+            Assert.Null(duid);
+        }
+
+        #endregion
+
+        #region Parse(string)
+        [Theory]
+        [MemberData(nameof(Parse_String_Success_Test_TestCases))]
+        public void Parse_Success_String_Test(byte[] expectedBytes, string inputString)
+        {
+            // Arrange
+            // Act
+            var duid = Duid.Parse(inputString);
+
+            // Assert
+            Assert.NotNull(duid);
+
+            Assert.IsType<Duid>(duid);
+            Assert.Equal(expectedBytes, duid.GetBytes());
+        }
+
+        [Theory]
+        [MemberData(nameof(Parse_String_Invalid_Test_TestCases))]
+        public void Parse_String_Invalid_Throws_ArgumentException_Test(string inputString)
+        {
+            // Arrange
+            // Act
+            // Assert
+            Assert.Throws<ArgumentException>(() => Duid.Parse(inputString));
+        }
+
+        [Theory]
+        [MemberData(nameof(Parse_String_Success_Test_TestCases))]
+        public void Parse_Success_IFormatProvider_String_Test(byte[] expectedBytes, string inputString)
+        {
+            // Arrange
+            // Act
+            var duid = Duid.Parse(inputString, null);
+
+            // Assert
+            Assert.NotNull(duid);
+
+            Assert.IsType<Duid>(duid);
+            Assert.Equal(expectedBytes, duid.GetBytes());
+        }
+
+        [Theory]
+        [MemberData(nameof(Parse_String_Invalid_Test_TestCases))]
+        public void Parse_String_IFormatProvider_Invalid_Throws_ArgumentException_Test(string inputString)
+        {
+            // Arrange
+            // Act
+            // Assert
+            Assert.Throws<ArgumentException>(() => Duid.Parse(inputString, null));
+        }
+
+        #endregion
+    }
+}

src/NetDuid.Tests/Duid.IComparableTests.cs

@@ -0,0 +1,115 @@
+using System;
+using Xunit;
+
+namespace NetDuid.Tests
+{
+    public partial class DuidTests
+    {
+        #region Compare(Duid)
+
+        public static TheoryData<int, Duid, Duid> Compare_Duid_Test_TestCases()
+        {
+            var theoryData = new TheoryData<int, Duid, Duid>();
+
+            var referenceDuid = new Duid(new byte[] { 0x00, 0x00, 0xff });
+
+            AddTestCase(0, referenceDuid, referenceDuid); // by reference
+            AddTestCase(-1, referenceDuid, null); // null case
+
+            // equality
+            AddCommutativeTestCases(0, new byte[] { 0x00, 0x00, 0x00 }, new byte[] { 0x00, 0x00, 0x00 });
+            AddCommutativeTestCases(0, new byte[] { 0xFF, 0x00, 0x80 }, new byte[] { 0xFF, 0x00, 0x80 });
+
+            // by length
+            AddCommutativeTestCases(-1, new byte[3], new byte[4]);
+            AddCommutativeTestCases(-1, new byte[3], new byte[130]);
+
+            // by length, then big endian value
+            AddCommutativeTestCases(-1, new byte[] { 0xFF, 0x00, 0x00 }, new byte[] { 0xFF, 0xFF, 0xFF, 0xFF });
+            AddCommutativeTestCases(-1, new byte[] { 0xFF, 0xFF, 0xFF }, new byte[] { 0xFF, 0x00, 0x00, 0x00 });
+            AddCommutativeTestCases(-1, new byte[] { 0x00, 0x00, 0x00 }, new byte[] { 0x00, 0x00, 0x01 });
+            AddCommutativeTestCases(-1, new byte[] { 0x00, 0x00, 0x00 }, new byte[] { 0x80, 0x00, 0x00 });
+
+            return theoryData;
+
+            void AddTestCase(int expectedSign, Duid thisDuid, Duid otherDuid)
+            {
+                theoryData.Add(expectedSign, thisDuid, otherDuid);
+            }
+
+            void AddCommutativeTestCases(int expectedSign, byte[] thisBytes, byte[] otherBytes)
+            {
+                AddTestCase(expectedSign, new Duid(thisBytes), new Duid(otherBytes));
+                AddTestCase(expectedSign * -1, new Duid(otherBytes), new Duid(thisBytes)); // Commutative test case form
+            }
+        }
+
+        [Theory]
+        [MemberData(nameof(Compare_Duid_Test_TestCases))]
+        public void Compare_Duid_Test(int expectedSign, Duid thisDuid, Duid otherDuid)
+        {
+            // Arrange
+            // Act
+            var result = thisDuid.CompareTo(otherDuid);
+
+            // Assert
+            if (expectedSign == 0)
+            {
+                // expected equivalent
+                Assert.Equal(0, result);
+            }
+            else if (expectedSign > 0)
+            {
+                // expected this after other
+                Assert.True(result > 0);
+            }
+            else if (expectedSign < 0)
+            {
+                // expected this before other
+                Assert.True(result < 0);
+            }
+        }
+
+        [Theory]
+        [MemberData(nameof(Compare_Duid_Test_TestCases))]
+        public void Compare_Object_Test(int expectedSign, Duid thisDuid, object other)
+        {
+            // Arrange
+            // Act
+            var result = thisDuid.CompareTo(other);
+
+            // Assert
+
+            if (expectedSign == 0)
+            {
+                // expected equivalent
+                Assert.Equal(0, result);
+            }
+            else if (expectedSign > 0)
+            {
+                // expected this after other
+                Assert.True(result > 0);
+            }
+            else if (expectedSign < 0)
+            {
+                // expected this before other
+                Assert.True(result < 0);
+            }
+        }
+
+        [Theory]
+        [InlineData("string")]
+        [InlineData(42)]
+        public void Compare_Object_NotDuid_Throws_ArgumentException_Test(object other)
+        {
+            // Arrange
+            var duid = new Duid(new byte[] { 0x00, 0x00, 0xff });
+
+            // Act
+            // Assert
+            Assert.Throws<ArgumentException>(() => duid.CompareTo(other));
+        }
+
+        #endregion
+    }
+}

src/NetDuid.Tests/Duid.IEquatableTests.cs

@@ -0,0 +1,118 @@
+using Xunit;
+
+namespace NetDuid.Tests
+{
+    public partial class DuidTests
+    {
+        #region Equal(Duid)
+
+        public static TheoryData<bool, Duid, Duid> Equal_Duid_Test_TestCases()
+        {
+            var theoryData = new TheoryData<bool, Duid, Duid>();
+
+            // reference equality
+            var referenceDuid = new Duid(new byte[] { 0x00, 0x00, 0xff });
+            AddTestCase(true, referenceDuid, referenceDuid); // by reference
+            AddTestCase(false, referenceDuid, null); // null case
+
+            // equality
+            AddCommutativeTestCases(true, new byte[] { 0x00, 0x00, 0x00 }, new byte[] { 0x00, 0x00, 0x00 });
+            AddCommutativeTestCases(true, new byte[] { 0xFF, 0x00, 0x80 }, new byte[] { 0xFF, 0x00, 0x80 });
+
+            // inequality
+            AddCommutativeTestCases(false, new byte[3], new byte[4]);
+            AddCommutativeTestCases(false, new byte[3], new byte[130]);
+            AddCommutativeTestCases(false, new byte[] { 0xFF, 0x00, 0x00 }, new byte[] { 0xFF, 0xFF, 0xFF, 0xFF });
+            AddCommutativeTestCases(false, new byte[] { 0xFF, 0xFF, 0xFF }, new byte[] { 0xFF, 0x00, 0x00, 0x00 });
+            AddCommutativeTestCases(false, new byte[] { 0x00, 0x00, 0x00 }, new byte[] { 0x00, 0x00, 0x01 });
+            AddCommutativeTestCases(false, new byte[] { 0x00, 0x00, 0x00 }, new byte[] { 0x80, 0x00, 0x00 });
+
+            return theoryData;
+
+            void AddTestCase(bool expectedEqual, Duid thisDuid, Duid otherDuid)
+            {
+                theoryData.Add(expectedEqual, thisDuid, otherDuid);
+            }
+
+            void AddCommutativeTestCases(bool expectedEqual, byte[] thisBytes, byte[] otherBytes)
+            {
+                AddTestCase(expectedEqual, new Duid(thisBytes), new Duid(otherBytes));
+                AddTestCase(expectedEqual, new Duid(otherBytes), new Duid(thisBytes)); // Commutative test case form
+            }
+        }
+
+        [Theory]
+        [MemberData(nameof(Equal_Duid_Test_TestCases))]
+        public void Equal_Duid_Test(bool expectedEqual, Duid thisDuid, Duid otherDuid)
+        {
+            // Arrange
+            // Act
+            var result = thisDuid.Equals(otherDuid);
+
+            // Assert
+            Assert.Equal(expectedEqual, result);
+
+            if (expectedEqual)
+            {
+                Assert.Equal(thisDuid.GetHashCode(), otherDuid.GetHashCode());
+            }
+        }
+
+        [Theory]
+        [MemberData(nameof(Equal_Duid_Test_TestCases))]
+        public void Equal_Object_Test(bool expectedEqual, Duid thisDuid, Duid otherDuid)
+        {
+            // Arrange
+            // Act
+            var result = thisDuid.Equals(otherDuid);
+
+            // Assert
+            Assert.Equal(expectedEqual, result);
+        }
+
+        [Theory]
+        [InlineData("string")]
+        [InlineData(42)]
+        [InlineData(null)]
+        public void Equal_Object_NotDuid_Throws_ArgumentException_Test(object other)
+        {
+            // Arrange
+            var duid = new Duid(new byte[] { 0x00, 0x00, 0xff });
+
+            // Act
+            var result = duid.Equals(other);
+
+            // Assert
+            Assert.False(result);
+        }
+
+        #endregion
+
+        #region GetHashCode
+        public static TheoryData<byte[]> HashCode_Test_TestCases()
+        {
+            var theoryData = new TheoryData<byte[]>();
+
+            for (var byteCount = 3; byteCount <= 130; byteCount += 5)
+            {
+                theoryData.Add(StaticTestData.GenerateBytes(byteCount, byteCount));
+            }
+
+            return theoryData;
+        }
+
+        [Theory]
+        [MemberData(nameof(HashCode_Test_TestCases))]
+        public void HashCode_EquivalentDuid_HashEqual_Test(byte[] duidBytes)
+        {
+            // Arrange
+            var duidA = new Duid(duidBytes);
+            var duidB = new Duid(duidBytes);
+
+            // Act
+            // Assert
+            Assert.Equal(duidA.GetHashCode(), duidB.GetHashCode());
+        }
+        #endregion
+    }
+}