Merge pull request #5 from synercoder/bug-fixes/inverse-multiplication-operator

Bug fixes/inverse multiplication operator

Author: synercoder

src/Synercoding.Primitives/UnitValue.cs

@@ -216,6 +216,15 @@ public bool Equals(UnitValue other)
         public static UnitValue operator *(UnitValue a, double b)
             => new UnitValue(a.Value * b, a.Unit);
 
+        /// <summary>
+        /// Multiply a given <see cref="UnitValue"/> by a <see cref="double"/>
+        /// </summary>
+        /// <param name="a">The <see cref="UnitValue"/> to multiply</param>
+        /// <param name="b">The <see cref="double"/> to multiply by</param>
+        /// <returns>The result of the multiplication operation</returns>
+        public static UnitValue operator *(double a, UnitValue b)
+            => new UnitValue(b.Value * a, b.Unit);
+
         /// <summary>
         /// Divide a given <see cref="UnitValue"/> by another <see cref="UnitValue"/>
         /// </summary>

tests/Synercoding.Primitives.Tests/UnitValueTests.cs

@@ -139,5 +139,39 @@ public void FromDesignation_WithPixels_ThrowsArgumentException()
 
             Assert.Throws<ArgumentException>(() => Unit.FromDesignation(designation));
         }
+
+        [Fact]
+        public void MultiplicationOperator_WithLeftDouble_IsUnitValue()
+        {
+            // Arrange
+            var left = 2d;
+            var right = new UnitValue(5, Unit.Millimeters);
+            var expected = new UnitValue(10, Unit.Millimeters);
+
+            // Act
+            var result = left * right;
+
+            // Assert
+            Assert.Equal(expected, result);
+            Assert.Equal(expected.Value, result.Value);
+            Assert.Equal(expected.Unit, result.Unit);
+        }
+
+        [Fact]
+        public void MultiplicationOperator_WithRightDouble_IsUnitValue()
+        {
+            // Arrange
+            var left = new UnitValue(5, Unit.Millimeters);
+            var right = 2d;
+            var expected = new UnitValue(10, Unit.Millimeters);
+
+            // Act
+            var result = left * right;
+
+            // Assert
+            Assert.Equal(expected, result);
+            Assert.Equal(expected.Value, result.Value);
+            Assert.Equal(expected.Unit, result.Unit);
+        }
     }
 }