Merge pull request #4 from synercoder/features/equality-operators

Features/equality operators

Author: synercoder

src/Synercoding.Primitives/Point.cs

@@ -89,5 +89,23 @@ public bool Equals(Point other)
         /// <inheritdoc />
         public override string ToString()
             => $"X: {X}, Y: {Y}";
+
+        /// <summary>
+        ///  Returns a value that indicates whether two specified <see cref="Point"/> values are equal.
+        /// </summary>
+        /// <param name="left">The first value to compare.</param>
+        /// <param name="right">The second value to compare.</param>
+        /// <returns>true if left and right are equal; otherwise, false.</returns>
+        public static bool operator ==(Point left, Point right)
+            => left.Equals(right);
+
+        /// <summary>
+        ///  Returns a value that indicates whether two specified <see cref="Point"/> values are not equal.
+        /// </summary>
+        /// <param name="left">The first value to compare.</param>
+        /// <param name="right">The second value to compare.</param>
+        /// <returns>true if left and right are not equal; otherwise, false.</returns>
+        public static bool operator !=(Point left, Point right)
+            => !( left == right );
     }
 }

src/Synercoding.Primitives/Rectangle.cs

@@ -163,5 +163,23 @@ public bool Equals(Rectangle other)
         /// <inheritdoc/>
         public override string ToString()
             => $"LLX {LLX}, LLY {LLY}, URX {URX}, URY {URY}";
+
+        /// <summary>
+        ///  Returns a value that indicates whether two specified <see cref="Rectangle"/> values are equal.
+        /// </summary>
+        /// <param name="left">The first value to compare.</param>
+        /// <param name="right">The second value to compare.</param>
+        /// <returns>true if left and right are equal; otherwise, false.</returns>
+        public static bool operator ==(Rectangle left, Rectangle right)
+            => left.Equals(right);
+
+        /// <summary>
+        ///  Returns a value that indicates whether two specified <see cref="Rectangle"/> values are not equal.
+        /// </summary>
+        /// <param name="left">The first value to compare.</param>
+        /// <param name="right">The second value to compare.</param>
+        /// <returns>true if left and right are not equal; otherwise, false.</returns>
+        public static bool operator !=(Rectangle left, Rectangle right)
+            => !( left == right );
     }
 }

src/Synercoding.Primitives/Size.cs

@@ -101,5 +101,23 @@ public bool Equals(Size other)
         /// <inheritdoc/>
         public override string ToString()
             => $"W: {Width}, H: {Height}";
+
+        /// <summary>
+        ///  Returns a value that indicates whether two specified <see cref="Size"/> values are equal.
+        /// </summary>
+        /// <param name="left">The first value to compare.</param>
+        /// <param name="right">The second value to compare.</param>
+        /// <returns>true if left and right are equal; otherwise, false.</returns>
+        public static bool operator ==(Size left, Size right)
+            => left.Equals(right);
+
+        /// <summary>
+        ///  Returns a value that indicates whether two specified <see cref="Size"/> values are not equal.
+        /// </summary>
+        /// <param name="left">The first value to compare.</param>
+        /// <param name="right">The second value to compare.</param>
+        /// <returns>true if left and right are not equal; otherwise, false.</returns>
+        public static bool operator !=(Size left, Size right)
+            => !( left == right );
     }
 }

src/Synercoding.Primitives/Spacing.cs

@@ -121,5 +121,23 @@ public bool Equals(Spacing other)
                 && a.Right == b.Right
                 && a.Bottom == b.Bottom;
         }
+
+        /// <summary>
+        ///  Returns a value that indicates whether two specified <see cref="Spacing"/> values are equal.
+        /// </summary>
+        /// <param name="left">The first value to compare.</param>
+        /// <param name="right">The second value to compare.</param>
+        /// <returns>true if left and right are equal; otherwise, false.</returns>
+        public static bool operator ==(Spacing left, Spacing right)
+            => left.Equals(right);
+
+        /// <summary>
+        ///  Returns a value that indicates whether two specified <see cref="Spacing"/> values are not equal.
+        /// </summary>
+        /// <param name="left">The first value to compare.</param>
+        /// <param name="right">The second value to compare.</param>
+        /// <returns>true if left and right are not equal; otherwise, false.</returns>
+        public static bool operator !=(Spacing left, Spacing right)
+            => !( left == right );
     }
 }

tests/Synercoding.Primitives.Tests/PointTests.cs

@@ -0,0 +1,35 @@
+using Xunit;
+
+namespace Synercoding.Primitives.Tests
+{
+    public class PointTests
+    {
+        [Fact]
+        public void EqualityOperator_InchAndMillimeters_NotEqual()
+        {
+            // Arrange
+            var mmPoint = new Point(1, 1, Unit.Millimeters);
+            var inPoint = new Point(1, 1, Unit.Inches);
+
+            // Act
+            var result = mmPoint == inPoint;
+
+            // Assert
+            Assert.False(result);
+        }
+
+        [Fact]
+        public void EqualityOperator_InchAnd254Millimeters_AreEqual()
+        {
+            // Arrange
+            var mmPoint = new Point(25.4, 25.4, Unit.Millimeters);
+            var inPoint = new Point(1, 1, Unit.Inches);
+
+            // Act
+            var result = mmPoint == inPoint;
+
+            // Assert
+            Assert.True(result);
+        }
+    }
+}

tests/Synercoding.Primitives.Tests/RectangleTests.cs

@@ -19,5 +19,33 @@ public void Expand_Spacing_ResultsInLargerRectangle()
             // Assert
             Assert.Equal(expected, result);
         }
+
+        [Fact]
+        public void EqualityOperator_InchAndMillimeters_NotEqual()
+        {
+            // Arrange
+            var mmRectangle = new Rectangle(1, 1, 1, 1, Unit.Millimeters);
+            var inRectangle = new Rectangle(1, 1, 1, 1, Unit.Inches);
+
+            // Act
+            var result = mmRectangle == inRectangle;
+
+            // Assert
+            Assert.False(result);
+        }
+
+        [Fact]
+        public void EqualityOperator_InchAnd254Millimeters_AreEqual()
+        {
+            // Arrange
+            var mmRectangle = new Rectangle(25.4, 25.4, 25.4, 25.4, Unit.Millimeters);
+            var inRectangle = new Rectangle(1, 1, 1, 1, Unit.Inches);
+
+            // Act
+            var result = mmRectangle == inRectangle;
+
+            // Assert
+            Assert.True(result);
+        }
     }
 }

tests/Synercoding.Primitives.Tests/SizeTests.cs

@@ -0,0 +1,35 @@
+using Xunit;
+
+namespace Synercoding.Primitives.Tests
+{
+    public class SizeTests
+    {
+        [Fact]
+        public void EqualityOperator_InchAndMillimeters_NotEqual()
+        {
+            // Arrange
+            var mmSize = new Size(1, 1, Unit.Millimeters);
+            var inSize = new Size(1, 1, Unit.Inches);
+
+            // Act
+            var result = mmSize == inSize;
+
+            // Assert
+            Assert.False(result);
+        }
+
+        [Fact]
+        public void EqualityOperator_InchAnd254Millimeters_AreEqual()
+        {
+            // Arrange
+            var mmSize = new Size(25.4, 25.4, Unit.Millimeters);
+            var inSize = new Size(1, 1, Unit.Inches);
+
+            // Act
+            var result = mmSize == inSize;
+
+            // Assert
+            Assert.True(result);
+        }
+    }
+}

tests/Synercoding.Primitives.Tests/SpacingTests.cs

@@ -0,0 +1,35 @@
+using Xunit;
+
+namespace Synercoding.Primitives.Tests
+{
+    public class SpacingTests
+    {
+        [Fact]
+        public void EqualityOperator_InchAndMillimeters_NotEqual()
+        {
+            // Arrange
+            var mmSpacing = new Spacing(1, 1, 1, 1, Unit.Millimeters);
+            var inSpacing = new Spacing(1, 1, 1, 1, Unit.Inches);
+
+            // Act
+            var result = mmSpacing == inSpacing;
+
+            // Assert
+            Assert.False(result);
+        }
+
+        [Fact]
+        public void EqualityOperator_InchAnd254Millimeters_AreEqual()
+        {
+            // Arrange
+            var mmSpacing = new Spacing(25.4, 25.4, 25.4, 25.4, Unit.Millimeters);
+            var inSpacing = new Spacing(1, 1, 1, 1, Unit.Inches);
+
+            // Act
+            var result = mmSpacing == inSpacing;
+
+            // Assert
+            Assert.True(result);
+        }
+    }
+}