(GH-81) fixed issue with deserialization of MaybeStruct none case.

src/BBT.MaybePattern.Tests/MaybeIntTests.cs

@@ -0,0 +1,53 @@
+namespace BBT.MaybePattern.Tests
+{
+    using BBT.MaybePattern;
+    using BBT.MaybePattern.Tests.TestData;
+    using Shouldly;
+    using Xunit;
+
+    public sealed class MaybeIntTests
+    {
+        public sealed class SerializeAndDeserialize
+        {
+            /// <summary>
+            /// Serialize and deserialize a maybe of int.
+            /// </summary>
+            [Fact]
+            public void Should_Work_For_None()
+            {
+                // Arrange
+                var maybe = Maybe.None<object>();
+                var testData = new TestDataClass() { Maybe = maybe };
+
+                // Act & Assert
+                using (var stream = TestUtils.SerializeToStream(testData))
+                {
+                    var testDataDeserialized = (TestDataClass)TestUtils.DeserializeFromStream(stream);
+
+                    testDataDeserialized.Maybe.ShouldBeOfType<Maybe<object>>();
+                    testDataDeserialized.Maybe.HasValue.ShouldBeFalse();
+                }
+            }
+
+            /// <summary>
+            /// Serialize and deserialize a maybe of int.
+            /// </summary>
+            [Fact]
+            public void Should_Work_For_Some()
+            {
+                // Arrange
+                var maybe = Maybe.Some<object>(new object());
+                var testData = new TestDataClass() { Maybe = maybe };
+
+                // Act & Assert
+                using (var stream = TestUtils.SerializeToStream(testData))
+                {
+                    var testDataDeserialized = (TestDataClass)TestUtils.DeserializeFromStream(stream);
+
+                    testDataDeserialized.Maybe.ShouldBeOfType<Maybe<object>>();
+                    testDataDeserialized.Maybe.HasValue.ShouldBeTrue();
+                }
+            }
+        }
+    }
+}

src/BBT.MaybePattern.Tests/MaybeStructIntTests.cs

@@ -0,0 +1,53 @@
+namespace BBT.MaybePattern.Tests
+{
+    using BBT.MaybePattern;
+    using BBT.MaybePattern.Tests.TestData;
+    using Shouldly;
+    using Xunit;
+
+    public sealed class MaybeStructIntTests
+    {
+        public sealed class SerializeAndDeserialize
+        {
+            /// <summary>
+            /// Serialize and deserialize a maybe of int.
+            /// </summary>
+            [Fact]
+            public void Should_Work_For_None()
+            {
+                // Arrange
+                var maybeStruct = Maybe.NoneStruct<int>();
+                var testData = new TestDataStruct() { MaybeStruct = maybeStruct };
+
+                // Act & Assert
+                using (var stream = TestUtils.SerializeToStream(testData))
+                {
+                    var testDataDeserialized = (TestDataStruct)TestUtils.DeserializeFromStream(stream);
+
+                    testDataDeserialized.MaybeStruct.ShouldBeOfType<MaybeStruct<int>>();
+                    testDataDeserialized.MaybeStruct.HasValue.ShouldBeFalse();
+                }
+            }
+
+            /// <summary>
+            /// Serialize and deserialize a maybe of int.
+            /// </summary>
+            [Fact]
+            public void Should_Work_For_Some()
+            {
+                // Arrange
+                var maybeStruct = Maybe.SomeStruct<int>(5);
+                var testData = new TestDataStruct() { MaybeStruct = maybeStruct };
+
+                // Act & Assert
+                using (var stream = TestUtils.SerializeToStream(testData))
+                {
+                    var testDataDeserialized = (TestDataStruct)TestUtils.DeserializeFromStream(stream);
+
+                    testDataDeserialized.MaybeStruct.ShouldBeOfType<MaybeStruct<int>>();
+                    testDataDeserialized.MaybeStruct.HasValue.ShouldBeTrue();
+                }
+            }
+        }
+    }
+}

src/BBT.MaybePattern.Tests/TestData/TestDataClass.cs

@@ -0,0 +1,16 @@
+namespace BBT.MaybePattern.Tests.TestData
+{
+    using System;
+
+    /// <summary>
+    /// Used for test purposes.
+    /// </summary>
+    [Serializable]
+    public class TestDataClass
+    {
+        /// <summary>
+        /// Gets or sets the maybe.
+        /// </summary>
+        public Maybe<object> Maybe { get; set; }
+    }
+}

src/BBT.MaybePattern.Tests/TestData/TestDataStruct.cs

@@ -0,0 +1,16 @@
+namespace BBT.MaybePattern.Tests.TestData
+{
+    using System;
+
+    /// <summary>
+    /// Used for test purposes.
+    /// </summary>
+    [Serializable]
+    public class TestDataStruct
+    {
+        /// <summary>
+        /// Gets or sets the maybe.
+        /// </summary>
+        public MaybeStruct<int> MaybeStruct { get; set; }
+    }
+}

src/BBT.MaybePattern.Tests/TestUtils.cs

@@ -0,0 +1,50 @@
+namespace BBT.MaybePattern.Tests
+{
+    using System;
+    using System.IO;
+    using System.Runtime.Serialization.Formatters.Binary;
+
+    /// <summary>
+    /// Provides utility method for test purposes.
+    /// </summary>
+    public class TestUtils
+    {
+        /// <summary>
+        /// Serializes the given object into memory stream.
+        /// </summary>
+        /// <param name="objectType">the object to be serialized.</param>
+        /// <returns>The serialized object as memory stream.</returns>
+        public static MemoryStream SerializeToStream(object objectType)
+        {
+            var stream = new MemoryStream();
+            try
+            {
+                var lFormatter = new BinaryFormatter();
+                lFormatter.Serialize(stream, objectType);
+                return stream;
+            }
+            catch
+            {
+                if (stream != null)
+                {
+                    stream.Dispose();
+                }
+            }
+
+            throw new InvalidOperationException();
+        }
+
+        /// <summary>
+        /// Deserializes as an object.
+        /// </summary>
+        /// <param name="stream">the stream to deserialize.</param>
+        /// <returns>the deserialized object.</returns>
+        public static object DeserializeFromStream(MemoryStream stream)
+        {
+            var formatter = new BinaryFormatter();
+            stream.Seek(0, SeekOrigin.Begin);
+            var objectType = formatter.Deserialize(stream);
+            return objectType;
+        }
+    }
+}

src/BBT.MaybePattern/MaybeStruct.cs

@@ -34,7 +34,7 @@ internal MaybeStruct(T? value)
         /// <param name="context">The streaming context.</param>
         internal MaybeStruct(SerializationInfo info, StreamingContext context)
         {
-            this.value = MaybeUtils.GetDeserializedValue<T>(info, nameof(this.value));
+            this.value = MaybeUtils.GetDeserializedValue<T?>(info, nameof(this.value));
         }
 
         /// <summary>