Add tests for struct with operators

Author: AArnott

src/ImmutableObjectGraph.Generation.Tests/TestSources/ImmutableWithComplexStructField.Tests.cs

@@ -10,13 +10,55 @@
     public class ImmutableWithComplexStructFieldTests
     {
         [Fact]
-        public void AssignVariousValues()
+        public void StructWithoutOperatorsAlwaysRecreatesObjectWithChangedValue()
         {
             var originalStruct = new SomeStructWithMultipleFields(5, 0);
             var structWithModifiedSecondField = new SomeStructWithMultipleFields(5, 1);
             var v1 = ImmutableWithComplexStructField.Create(someStructField: originalStruct);
             var v2 = v1.With(someStructField: structWithModifiedSecondField);
             Assert.Equal(structWithModifiedSecondField.Field2, v2.SomeStructField.Field2);
         }
+
+        [Fact]
+        public void StructWithoutOperatorsAlwaysRecreatesObjectWithSameValue()
+        {
+            var s1 = new SomeStructWithMultipleFields(1, 2);
+            var v1 = ImmutableWithComplexStructField.Create(someStructField: s1);
+            var v2 = v1.With(someStructField: s1);
+
+            // The object should have been recreated since equality between the two struct values
+            // cannot be determined without their operator defined.
+            Assert.NotSame(v1, v2);
+            Assert.Equal(s1.Field1, v2.SomeStructField.Field1);
+        }
+
+        [Fact]
+        public void StructWithoutOperatorsAlwaysRecreatesObjectWithoutValue()
+        {
+            var s1 = new SomeStructWithMultipleFields(1, 2);
+            var v1 = ImmutableWithComplexStructField.Create(someStructField: s1);
+            var v2 = v1.With(); // omit the struct value altogether
+            Assert.Same(v1, v2);
+        }
+
+        [Fact]
+        public void StructWithOperatorsRecreatesObjectWithChangedValue()
+        {
+            var s12 = new SomeStructWithMultipleFieldsAndOperator(1, 2);
+            var s13 = new SomeStructWithMultipleFieldsAndOperator(1, 3);
+            var v1 = ImmutableWithComplexStructField.Create(someStructFieldWithOperator: s12);
+            var v2 = v1.With(someStructFieldWithOperator: s13);
+            Assert.NotSame(v1, v2);
+            Assert.Equal(s13.Field2, v2.SomeStructFieldWithOperator.Field2);
+        }
+
+        [Fact]
+        public void StructWithOperatorsRecyclesObjectWithSameValue()
+        {
+            var s12 = new SomeStructWithMultipleFieldsAndOperator(1, 2);
+            var v1 = ImmutableWithComplexStructField.Create(someStructFieldWithOperator: s12);
+            var v2 = v1.With(someStructFieldWithOperator: s12);
+            Assert.Same(v1, v2);
+        }
     }
 }

src/ImmutableObjectGraph.Generation.Tests/TestSources/ImmutableWithComplexStructField.cs

@@ -1,9 +1,13 @@
 namespace ImmutableObjectGraph.Generation.Tests.TestSources
 {
+    using System;
+
     [GenerateImmutable]
     partial class ImmutableWithComplexStructField
     {
         readonly SomeStructWithMultipleFields someStructField;
+
+        readonly SomeStructWithMultipleFieldsAndOperator someStructFieldWithOperator;
     }
 
     struct SomeStructWithMultipleFields
@@ -17,15 +21,38 @@ internal SomeStructWithMultipleFields(int field1, int field2)
         internal int Field1 { get; }
 
         internal int Field2 { get; }
+    }
+
+    struct SomeStructWithMultipleFieldsAndOperator
+    {
+        internal SomeStructWithMultipleFieldsAndOperator(int field1, int field2)
+        {
+            this.Field1 = field1;
+            this.Field2 = field2;
+        }
 
-        ////public static bool operator ==(SomeStructWithMultipleFields one, SomeStructWithMultipleFields two)
-        ////{
-        ////    return one.Field1 == two.Field1 && one.Field2 == two.Field2;
-        ////}
+        internal int Field1 { get; }
+
+        internal int Field2 { get; }
 
-        ////public static bool operator !=(SomeStructWithMultipleFields one, SomeStructWithMultipleFields two)
-        ////{
-        ////    return !(one == two);
-        ////}
+        public static bool operator ==(SomeStructWithMultipleFieldsAndOperator one, SomeStructWithMultipleFieldsAndOperator two)
+        {
+            return one.Field1 == two.Field1 && one.Field2 == two.Field2;
+        }
+
+        public static bool operator !=(SomeStructWithMultipleFieldsAndOperator one, SomeStructWithMultipleFieldsAndOperator two)
+        {
+            return !(one == two);
+        }
+
+        public override bool Equals(object obj)
+        {
+            throw new NotImplementedException();
+        }
+
+        public override int GetHashCode()
+        {
+            throw new NotImplementedException();
+        }
     }
 }

src/ImmutableObjectGraph/Optional.cs

@@ -1,11 +1,9 @@
-namespace ImmutableObjectGraph {
-	using System;
-	using System.Collections.Generic;
-	using System.Linq;
-	using System.Text;
-	using System.Threading.Tasks;
+namespace ImmutableObjectGraph
+{
+	using System.Diagnostics;
 
 	public static class Optional {
+		[DebuggerStepThrough]
 		public static Optional<T> For<T>(T value) {
 			return value;
 		}

src/ImmutableObjectGraph/Optional`1.cs

@@ -57,6 +57,7 @@ public static implicit operator Optional<T>(T value) {
 		/// </summary>
 		/// <param name="defaultValue">The default value to use if a value was not specified.</param>
 		/// <returns>The value.</returns>
+		[DebuggerStepThrough]
 		public T GetValueOrDefault(T defaultValue) {
 			return this.IsDefined ? this.value : defaultValue;
 		}