Add StringEnumTests

Author: Joelius300

ChartJs.Blazor.Tests/StringEnumTests.Deserialization.cs

@@ -0,0 +1,91 @@
+using ChartJs.Blazor.ChartJS.Common.Enums;
+using Newtonsoft.Json;
+using System;
+using System.Globalization;
+using Xunit;
+
+namespace ChartJs.Blazor.Tests
+{
+    public partial class StringEnumTests
+    {
+        [Theory]
+        [InlineData("\"foo\"", "foo")]
+        [InlineData("\"Hello World!\"", "Hello World!")]
+        [InlineData("\"\\\"That's what!\\\", she said.\"", "\"That's what!\", she said.")]
+        [InlineData("\"¨öä$ü¨^'{}][\\\\|/-.,+-/*\"", "¨öä$ü¨^'{}][\\|/-.,+-/*")]
+        public void Deserialize_StringEnum_FromRoot(string json, string expectedValue)
+        {
+            // Act
+            TestStringEnum stringEnum = JsonConvert.DeserializeObject<TestStringEnum>(json);
+
+            // Assert
+            Assert.True(stringEnum.Equals(expectedValue)); // expects all the equality stuff to be correct
+        }
+
+        [Fact]
+        public void Deserialize_Int_ThrowsNotSupported()
+        {
+            // Arrange
+            const string json = "0";
+
+            // Act & Assert
+            Assert.Throws<NotSupportedException>(() => JsonConvert.DeserializeObject<TestStringEnum>(json));
+        }
+
+        [Fact]
+        public void Deserialize_Double_ThrowsNotSupported()
+        {
+            // Arrange
+            const string json = "0.0";
+
+            // Act & Assert
+            Assert.Throws<NotSupportedException>(() => JsonConvert.DeserializeObject<TestStringEnum>(json));
+        }
+
+        [Fact]
+        public void Deserialize_JsonArray_ThrowsNotSupported()
+        {
+            // Arrange
+            const string json = "[1,2,3]";
+
+            // Act & Assert
+            Assert.Throws<NotSupportedException>(() => JsonConvert.DeserializeObject<TestStringEnum>(json));
+        }
+
+        [Fact]
+        public void Deserialize_JsonObject_ThrowsNotSupported()
+        {
+            // Arrange
+            string json = "{}";
+
+            // Act & Assert
+            Assert.Throws<NotSupportedException>(() => JsonConvert.DeserializeObject<TestStringEnum>(json));
+        }
+
+        [Fact]
+        public void Deserialize_Null_ReturnsNull()
+        {
+            // Arrange
+            string json = "null";
+
+            // Act
+            TestStringEnum stringEnum = JsonConvert.DeserializeObject<TestStringEnum>(json);
+
+            // Assert
+            Assert.Null(stringEnum);
+        }
+
+        [Fact]
+        public void Deserialize_Undefined_ReturnsNull()
+        {
+            // Arrange
+            string json = "undefined";
+
+            // Act
+            TestStringEnum stringEnum = JsonConvert.DeserializeObject<TestStringEnum>(json);
+
+            // Assert
+            Assert.Null(stringEnum);
+        }
+    }
+}

ChartJs.Blazor.Tests/StringEnumTests.Equality.cs

@@ -0,0 +1,150 @@
+using ChartJs.Blazor.ChartJS.Common.Enums;
+using Newtonsoft.Json;
+using System;
+using System.Globalization;
+using Xunit;
+
+namespace ChartJs.Blazor.Tests
+{
+    public partial class StringEnumTests
+    {
+        [Fact]
+        public void Equals_StringEnumAndStringEnum_ReturnsTrue()
+        {
+            // Arrange
+            var a = TestStringEnum.Auto;
+            var b = TestStringEnum.Auto; // different instance, same inner value
+
+            // Act
+            bool equal = a.Equals(b);
+
+            // Assert
+            Assert.True(equal);
+        }
+
+        [Fact]
+        public void Equals_StringEnumAndString_ReturnsTrue()
+        {
+            // Arrange
+            const string ExampleStringValue = "abcdefg";
+            var a = TestStringEnum.Custom(ExampleStringValue);
+
+            // Act
+            bool equal = a.Equals(ExampleStringValue);
+
+            // Assert
+            Assert.True(equal);
+        }
+
+        [Fact]
+        public void Equals_EnumAndNull_ReturnsFalse()
+        {
+            // Arrange
+            var a = TestStringEnum.Custom(string.Empty);
+
+            // Act
+            bool equal = a.Equals(null);
+
+            // Assert
+            Assert.False(equal);
+        }
+
+        [Fact]
+        public void Equals_SameReference_ReturnsTrue()
+        {
+            // Arrange
+            var a = TestStringEnum.Custom(string.Empty);
+            var b = a;
+
+            // Act
+            bool equal = a.Equals(b);
+
+            // Assert
+            Assert.True(equal);
+        }
+
+        [Fact]
+        public void EqualityOperator_StringEnumAndStringEnum_ReturnsTrue()
+        {
+            // Arrange
+            var a = TestStringEnum.Auto;
+            var b = TestStringEnum.Auto; // different instance, same inner value
+
+            // Act
+            bool equal = a == b;
+
+            // Assert
+            Assert.True(equal);
+        }
+
+        [Fact]
+        public void EqualityOperator_StringEnumAndNull_ReturnsFalse()
+        {
+            // Arrange
+            var a = TestStringEnum.Custom(string.Empty);
+
+            // Act
+            bool equal = a == null;
+
+            // Assert
+            Assert.False(equal);
+        }
+
+        [Fact]
+        public void EqualityOperator_NullAndNull_ReturnsTrue()
+        {
+            // Arrange
+            TestStringEnum a = null;
+
+            // Act
+            bool equal = a == null;
+
+            // Assert
+            Assert.True(equal);
+        }
+
+        [Fact]
+        public void EqualityOperator_SameReference_ReturnsTrue()
+        {
+            // Arrange
+            var a = TestStringEnum.Custom(string.Empty);
+            var b = a;
+
+            // Act
+            bool equal = a == b;
+
+            // Assert
+            Assert.True(equal);
+        }
+
+        [Fact]
+        public void GetHashCode_InnerValueAndEnum_Equals()
+        {
+            // Arrange
+            const string ExampleString = "asdf";
+            TestStringEnum stringEnum = TestStringEnum.Custom(ExampleString);
+
+            // Act
+            int hashCodeValue = ExampleString.GetHashCode();
+            int hashCodeEnum = stringEnum.GetHashCode();
+
+            // Assert
+            Assert.Equal(hashCodeValue, hashCodeEnum);
+        }
+        
+        [Fact]
+        public void GetHashCode_EnumAndEnum_Equals()
+        {
+            // Arrange
+            var a = TestStringEnum.Auto;
+            var b = TestStringEnum.Auto; // different instance, same inner value
+
+            // Act
+            int hashA = a.GetHashCode();
+            int hashB = b.GetHashCode();
+
+            // Assert
+            Assert.Equal(hashA, hashB);
+        }
+    }
+}

ChartJs.Blazor.Tests/StringEnumTests.General.cs

@@ -0,0 +1,17 @@
+using ChartJs.Blazor.ChartJS.Common.Enums;
+using Newtonsoft.Json;
+using System;
+using System.Globalization;
+using Xunit;
+
+namespace ChartJs.Blazor.Tests
+{
+    public partial class StringEnumTests
+    {
+        [Fact]
+        public void Construct_NullValue_ThrowsArgumentNullException()
+        {
+            Assert.Throws<ArgumentNullException>(() => TestStringEnum.Custom(null));
+        }
+    }
+}

ChartJs.Blazor.Tests/StringEnumTests.Serialization.cs

@@ -0,0 +1,33 @@
+using ChartJs.Blazor.ChartJS.Common.Enums;
+using Newtonsoft.Json;
+using System;
+using System.Globalization;
+using Xunit;
+
+namespace ChartJs.Blazor.Tests
+{
+    public partial class StringEnumTests
+    {
+        [Theory]
+        [InlineData("foo")]
+        [InlineData("bar")]
+        [InlineData("1234567890")]
+        [InlineData("")]
+        [InlineData("whomst'd've'ly'yaint'nt'ed'ies's'y'es")]
+        [InlineData("\"That's what!\", she said.")]
+        [InlineData("\uD83D\uDE42 emoji shenanigans")]
+        [InlineData("¨öä$ü¨^'{}][\\|/-.,+-/*")]
+        public void Serialize_StringEnum_AsRoot(string value)
+        {
+            // Arrange
+            TestStringEnum objEnum = TestStringEnum.Custom(value);
+            string escapedValue = JsonConvert.ToString(value);
+
+            // Act
+            string serialized = JsonConvert.SerializeObject(objEnum);
+
+            // Assert
+            Assert.Equal(escapedValue, serialized);
+        }
+    }
+}

ChartJs.Blazor.Tests/StringEnumTests.TestClasses.cs

@@ -0,0 +1,19 @@
+using ChartJs.Blazor.ChartJS.Common.Enums;
+using Newtonsoft.Json;
+using System;
+using System.Globalization;
+using Xunit;
+
+namespace ChartJs.Blazor.Tests
+{
+    public partial class StringEnumTests
+    {
+        private class TestStringEnum : StringEnum
+        {
+            public static TestStringEnum Auto => new TestStringEnum("auto");
+            public static TestStringEnum Custom(string value) => new TestStringEnum(value);
+
+            private TestStringEnum(string stringRep) : base(stringRep) { }
+        }
+    }
+}