feat: add LowestCommonMultiple for built-in integer types

This was previously incorrectly documented in CHANGELOG.md. The method now exists. Sorry about that
oliverbooth · Mar 31, 2023 · 275d98f · 275d98f
1 parent 9ee99d7
commit 275d98f
Show file tree

Hide file tree

Showing 16 changed files with 616 additions and 1 deletion.
diff --git a/X10D.Tests/src/Math/ByteTests.cs b/X10D.Tests/src/Math/ByteTests.cs
@@ -72,6 +72,56 @@ public void IsOddShouldBeCorrect()
         Assert.IsFalse(two.IsOdd());
     }
 
+    [TestMethod]
+    public void LowestCommonMultiple_ShouldReturnCorrectValue_WhenCalledWithValidInput()
+    {
+        const byte value1 = 2;
+        const byte value2 = 3;
+        const byte expected = 6;
+
+        byte result = value1.LowestCommonMultiple(value2);
+
+        Assert.AreEqual(expected, result);
+    }
+
+    [TestMethod]
+    public void LowestCommonMultiple_ShouldReturnZero_WhenCalledWithZero()
+    {
+        const byte value1 = 0;
+        const byte value2 = 10;
+        const byte expected = 0;
+
+        byte result = value1.LowestCommonMultiple(value2);
+
+        Assert.AreEqual(expected, result);
+    }
+
+    [TestMethod]
+    public void LowestCommonMultiple_ShouldReturnGreaterValue_WhenCalledWithOne()
+    {
+        const byte value1 = 1;
+        const byte value2 = 10;
+        const byte expected = 10;
+
+        byte result1 = value1.LowestCommonMultiple(value2);
+        byte result2 = value2.LowestCommonMultiple(value1);
+
+        Assert.AreEqual(expected, result1);
+        Assert.AreEqual(expected, result2);
+    }
+
+    [TestMethod]
+    public void LowestCommonMultiple_ShouldReturnOtherValue_WhenCalledWithSameValue()
+    {
+        const byte value1 = 5;
+        const byte value2 = 5;
+        const byte expected = 5;
+
+        byte result = value1.LowestCommonMultiple(value2);
+
+        Assert.AreEqual(expected, result);
+    }
+
     [TestMethod]
     public void MultiplicativePersistence_ShouldBeCorrect_ForRecordHolders()
     {

diff --git a/X10D.Tests/src/Math/Int16Tests.cs b/X10D.Tests/src/Math/Int16Tests.cs
@@ -72,6 +72,68 @@ public void IsOddShouldBeCorrect()
         Assert.IsFalse(two.IsOdd());
     }
 
+    [TestMethod]
+    public void LowestCommonMultiple_ShouldReturnCorrectValue_WhenCalledWithValidInput()
+    {
+        const short value1 = 2;
+        const short value2 = 3;
+        const short expected = 6;
+
+        short result = value1.LowestCommonMultiple(value2);
+
+        Assert.AreEqual(expected, result);
+    }
+
+    [TestMethod]
+    public void LowestCommonMultiple_ShouldReturnZero_WhenCalledWithZero()
+    {
+        const short value1 = 0;
+        const short value2 = 10;
+        const short expected = 0;
+
+        short result = value1.LowestCommonMultiple(value2);
+
+        Assert.AreEqual(expected, result);
+    }
+
+    [TestMethod]
+    public void LowestCommonMultiple_ShouldReturnGreaterValue_WhenCalledWithOne()
+    {
+        const short value1 = 1;
+        const short value2 = 10;
+        const short expected = 10;
+
+        short result1 = value1.LowestCommonMultiple(value2);
+        short result2 = value2.LowestCommonMultiple(value1);
+
+        Assert.AreEqual(expected, result1);
+        Assert.AreEqual(expected, result2);
+    }
+
+    [TestMethod]
+    public void LowestCommonMultiple_ShouldReturnOtherValue_WhenCalledWithSameValue()
+    {
+        const short value1 = 5;
+        const short value2 = 5;
+        const short expected = 5;
+
+        short result = value1.LowestCommonMultiple(value2);
+
+        Assert.AreEqual(expected, result);
+    }
+
+    [TestMethod]
+    public void LowestCommonMultiple_ShouldReturnCorrectValue_WhenCalledWithNegativeValues()
+    {
+        const short value1 = -2;
+        const short value2 = 3;
+        const short expected = -6;
+
+        short result = value1.LowestCommonMultiple(value2);
+
+        Assert.AreEqual(expected, result);
+    }
+
     [TestMethod]
     public void MultiplicativePersistence_ShouldBeCorrect_ForRecordHolders()
     {

diff --git a/X10D.Tests/src/Math/Int32Tests.cs b/X10D.Tests/src/Math/Int32Tests.cs
@@ -72,6 +72,68 @@ public void IsOddShouldBeCorrect()
         Assert.IsFalse(two.IsOdd());
     }
 
+    [TestMethod]
+    public void LowestCommonMultiple_ShouldReturnCorrectValue_WhenCalledWithValidInput()
+    {
+        const int value1 = 2;
+        const int value2 = 3;
+        const int expected = 6;
+
+        int result = value1.LowestCommonMultiple(value2);
+
+        Assert.AreEqual(expected, result);
+    }
+
+    [TestMethod]
+    public void LowestCommonMultiple_ShouldReturnZero_WhenCalledWithZero()
+    {
+        const int value1 = 0;
+        const int value2 = 10;
+        const int expected = 0;
+
+        int result = value1.LowestCommonMultiple(value2);
+
+        Assert.AreEqual(expected, result);
+    }
+
+    [TestMethod]
+    public void LowestCommonMultiple_ShouldReturnGreaterValue_WhenCalledWithOne()
+    {
+        const int value1 = 1;
+        const int value2 = 10;
+        const int expected = 10;
+
+        int result = value1.LowestCommonMultiple(value2);
+
+        Assert.AreEqual(expected, result);
+    }
+
+    [TestMethod]
+    public void LowestCommonMultiple_ShouldReturnOtherValue_WhenCalledWithSameValue()
+    {
+        const int value1 = 5;
+        const int value2 = 5;
+        const int expected = 5;
+
+        int result = value1.LowestCommonMultiple(value2);
+
+        Assert.AreEqual(expected, result);
+    }
+
+    [TestMethod]
+    public void LowestCommonMultiple_ShouldReturnCorrectValue_WhenCalledWithNegativeValues()
+    {
+        const int value1 = -2;
+        const int value2 = 3;
+        const int expected = -6;
+
+        int result1 = value1.LowestCommonMultiple(value2);
+        int result2 = value2.LowestCommonMultiple(value1);
+
+        Assert.AreEqual(expected, result1);
+        Assert.AreEqual(expected, result2);
+    }
+
     [TestMethod]
     public void MultiplicativePersistence_ShouldBeCorrect_ForRecordHolders()
     {

diff --git a/X10D.Tests/src/Math/Int64Tests.cs b/X10D.Tests/src/Math/Int64Tests.cs
@@ -72,6 +72,68 @@ public void IsOddShouldBeCorrect()
         Assert.IsFalse(two.IsOdd());
     }
 
+    [TestMethod]
+    public void LowestCommonMultiple_ShouldReturnCorrectValue_WhenCalledWithValidInput()
+    {
+        const long value1 = 2;
+        const long value2 = 3;
+        const long expected = 6;
+
+        long result = value1.LowestCommonMultiple(value2);
+
+        Assert.AreEqual(expected, result);
+    }
+
+    [TestMethod]
+    public void LowestCommonMultiple_ShouldReturnZero_WhenCalledWithZero()
+    {
+        const long value1 = 0;
+        const long value2 = 10;
+        const long expected = 0;
+
+        long result = value1.LowestCommonMultiple(value2);
+
+        Assert.AreEqual(expected, result);
+    }
+
+    [TestMethod]
+    public void LowestCommonMultiple_ShouldReturnGreaterValue_WhenCalledWithOne()
+    {
+        const long value1 = 1;
+        const long value2 = 10;
+        const long expected = 10;
+
+        long result1 = value1.LowestCommonMultiple(value2);
+        long result2 = value2.LowestCommonMultiple(value1);
+
+        Assert.AreEqual(expected, result1);
+        Assert.AreEqual(expected, result2);
+    }
+
+    [TestMethod]
+    public void LowestCommonMultiple_ShouldReturnOtherValue_WhenCalledWithSameValue()
+    {
+        const long value1 = 5;
+        const long value2 = 5;
+        const long expected = 5;
+
+        long result = value1.LowestCommonMultiple(value2);
+
+        Assert.AreEqual(expected, result);
+    }
+
+    [TestMethod]
+    public void LowestCommonMultiple_ShouldReturnCorrectValue_WhenCalledWithNegativeValues()
+    {
+        const long value1 = -2;
+        const long value2 = 3;
+        const long expected = -6;
+
+        long result = value1.LowestCommonMultiple(value2);
+
+        Assert.AreEqual(expected, result);
+    }
+
     [TestMethod]
     public void MultiplicativePersistence_ShouldBeCorrect_ForRecordHolders()
     {

diff --git a/X10D.Tests/src/Math/SByteTests.cs b/X10D.Tests/src/Math/SByteTests.cs
@@ -73,6 +73,68 @@ public void IsOddShouldBeCorrect()
         Assert.IsFalse(two.IsOdd());
     }
 
+    [TestMethod]
+    public void LowestCommonMultiple_ShouldReturnCorrectValue_WhenCalledWithValidInput()
+    {
+        const sbyte value1 = 2;
+        const sbyte value2 = 3;
+        const sbyte expected = 6;
+
+        sbyte result = value1.LowestCommonMultiple(value2);
+
+        Assert.AreEqual(expected, result);
+    }
+
+    [TestMethod]
+    public void LowestCommonMultiple_ShouldReturnZero_WhenCalledWithZero()
+    {
+        const sbyte value1 = 0;
+        const sbyte value2 = 10;
+        const sbyte expected = 0;
+
+        sbyte result = value1.LowestCommonMultiple(value2);
+
+        Assert.AreEqual(expected, result);
+    }
+
+    [TestMethod]
+    public void LowestCommonMultiple_ShouldReturnGreaterValue_WhenCalledWithOne()
+    {
+        const sbyte value1 = 1;
+        const sbyte value2 = 10;
+        const sbyte expected = 10;
+
+        sbyte result = value1.LowestCommonMultiple(value2);
+
+        Assert.AreEqual(expected, result);
+    }
+
+    [TestMethod]
+    public void LowestCommonMultiple_ShouldReturnOtherValue_WhenCalledWithSameValue()
+    {
+        const sbyte value1 = 5;
+        const sbyte value2 = 5;
+        const sbyte expected = 5;
+
+        sbyte result1 = value1.LowestCommonMultiple(value2);
+        sbyte result2 = value2.LowestCommonMultiple(value1);
+
+        Assert.AreEqual(expected, result1);
+        Assert.AreEqual(expected, result2);
+    }
+
+    [TestMethod]
+    public void LowestCommonMultiple_ShouldReturnCorrectValue_WhenCalledWithNegativeValues()
+    {
+        const sbyte value1 = -2;
+        const sbyte value2 = 3;
+        const sbyte expected = -6;
+
+        sbyte result = value1.LowestCommonMultiple(value2);
+
+        Assert.AreEqual(expected, result);
+    }
+
     [TestMethod]
     public void MultiplicativePersistence_ShouldBeCorrect_ForRecordHolders()
     {

diff --git a/X10D.Tests/src/Math/UInt16Tests.cs b/X10D.Tests/src/Math/UInt16Tests.cs
@@ -73,6 +73,56 @@ public void IsOddShouldBeCorrect()
         Assert.IsFalse(two.IsOdd());
     }
 
+    [TestMethod]
+    public void LowestCommonMultiple_ShouldReturnCorrectValue_WhenCalledWithValidInput()
+    {
+        const ushort value1 = 2;
+        const ushort value2 = 3;
+        const ushort expected = 6;
+
+        ushort result = value1.LowestCommonMultiple(value2);
+
+        Assert.AreEqual(expected, result);
+    }
+
+    [TestMethod]
+    public void LowestCommonMultiple_ShouldReturnZero_WhenCalledWithZero()
+    {
+        const ushort value1 = 0;
+        const ushort value2 = 10;
+        const ushort expected = 0;
+
+        ushort result = value1.LowestCommonMultiple(value2);
+
+        Assert.AreEqual(expected, result);
+    }
+
+    [TestMethod]
+    public void LowestCommonMultiple_ShouldReturnGreaterValue_WhenCalledWithOne()
+    {
+        const ushort value1 = 1;
+        const ushort value2 = 10;
+        const ushort expected = 10;
+
+        ushort result1 = value1.LowestCommonMultiple(value2);
+        ushort result2 = value2.LowestCommonMultiple(value1);
+
+        Assert.AreEqual(expected, result1);
+        Assert.AreEqual(expected, result2);
+    }
+
+    [TestMethod]
+    public void LowestCommonMultiple_ShouldReturnOtherValue_WhenCalledWithSameValue()
+    {
+        const ushort value1 = 5;
+        const ushort value2 = 5;
+        const ushort expected = 5;
+
+        ushort result = value1.LowestCommonMultiple(value2);
+
+        Assert.AreEqual(expected, result);
+    }
+
     [TestMethod]
     public void MultiplicativePersistence_ShouldBeCorrect_ForRecordHolders()
     {