Add unit tests for PowerAccent.Core and Peek.Common helpers

src/modules/peek/Peek.Common.UnitTests/MathHelperTests.cs

@@ -0,0 +1,160 @@
+// Copyright (c) Microsoft Corporation
+// The Microsoft Corporation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+using Peek.Common.Helpers;
+
+namespace Peek.Common.UnitTests
+{
+    [TestClass]
+    public class MathHelperTests
+    {
+        #region Modulo
+
+        [TestMethod]
+        public void Modulo_PositiveNumbers_ShouldReturnStandardModulo()
+        {
+            Assert.AreEqual(1, MathHelper.Modulo(7, 3));
+        }
+
+        [TestMethod]
+        public void Modulo_ZeroDividend_ShouldReturnZero()
+        {
+            Assert.AreEqual(0, MathHelper.Modulo(0, 5));
+        }
+
+        [TestMethod]
+        public void Modulo_ExactDivision_ShouldReturnZero()
+        {
+            Assert.AreEqual(0, MathHelper.Modulo(6, 3));
+        }
+
+        [TestMethod]
+        public void Modulo_NegativeDividend_ShouldReturnPositiveResult()
+        {
+            // -1 % 3 in C# returns -1, but Modulo should return 2
+            Assert.AreEqual(2, MathHelper.Modulo(-1, 3));
+        }
+
+        [TestMethod]
+        public void Modulo_NegativeDividend_LargerMagnitude_ShouldWrapCorrectly()
+        {
+            // -7 % 3: C# gives -1; proper modulo: (-7 % 3 + 3) % 3 = (-1 + 3) % 3 = 2
+            Assert.AreEqual(2, MathHelper.Modulo(-7, 3));
+        }
+
+        [TestMethod]
+        public void Modulo_NegativeDividend_ExactMultiple_ShouldReturnZero()
+        {
+            // -6 % 3 = 0
+            Assert.AreEqual(0, MathHelper.Modulo(-6, 3));
+        }
+
+        [TestMethod]
+        public void Modulo_PositiveDividend_DivisorOne_ShouldReturnZero()
+        {
+            Assert.AreEqual(0, MathHelper.Modulo(5, 1));
+        }
+
+        [TestMethod]
+        public void Modulo_NegativeDividend_DivisorOne_ShouldReturnZero()
+        {
+            Assert.AreEqual(0, MathHelper.Modulo(-5, 1));
+        }
+
+        [TestMethod]
+        public void Modulo_LargePositiveNumbers_ShouldWork()
+        {
+            Assert.AreEqual(1, MathHelper.Modulo(1000001, 1000000));
+        }
+
+        [TestMethod]
+        public void Modulo_DividendLessThanDivisor_ShouldReturnDividend()
+        {
+            Assert.AreEqual(2, MathHelper.Modulo(2, 5));
+        }
+
+        [TestMethod]
+        public void Modulo_NegativeDividend_MinusTwo_ModThree_ShouldReturnOne()
+        {
+            Assert.AreEqual(1, MathHelper.Modulo(-2, 3));
+        }
+
+        #endregion
+
+        #region NumberOfDigits
+
+        [TestMethod]
+        public void NumberOfDigits_Zero_ShouldReturnOne()
+        {
+            Assert.AreEqual(1, MathHelper.NumberOfDigits(0));
+        }
+
+        [TestMethod]
+        public void NumberOfDigits_SingleDigit_ShouldReturnOne()
+        {
+            Assert.AreEqual(1, MathHelper.NumberOfDigits(5));
+        }
+
+        [TestMethod]
+        public void NumberOfDigits_TwoDigits_ShouldReturnTwo()
+        {
+            Assert.AreEqual(2, MathHelper.NumberOfDigits(42));
+        }
+
+        [TestMethod]
+        public void NumberOfDigits_ThreeDigits_ShouldReturnThree()
+        {
+            Assert.AreEqual(3, MathHelper.NumberOfDigits(100));
+        }
+
+        [TestMethod]
+        public void NumberOfDigits_NegativeNumber_ShouldIgnoreSign()
+        {
+            Assert.AreEqual(3, MathHelper.NumberOfDigits(-123));
+        }
+
+        [TestMethod]
+        public void NumberOfDigits_MaxValue_ShouldReturnTenDigits()
+        {
+            // int.MaxValue = 2147483647, which has 10 digits
+            Assert.AreEqual(10, MathHelper.NumberOfDigits(int.MaxValue));
+        }
+
+        [TestMethod]
+        public void NumberOfDigits_MinValue_ShouldHandleAbsoluteValue()
+        {
+            // int.MinValue = -2147483648, Math.Abs would overflow but ToString handles it
+            // The implementation uses Math.Abs(num).ToString().Length
+            // For int.MinValue, Math.Abs throws - test the boundary just above it
+            Assert.AreEqual(10, MathHelper.NumberOfDigits(int.MinValue + 1));
+        }
+
+        [TestMethod]
+        public void NumberOfDigits_PowerOfTen_ShouldReturnCorrectCount()
+        {
+            Assert.AreEqual(1, MathHelper.NumberOfDigits(1));
+            Assert.AreEqual(2, MathHelper.NumberOfDigits(10));
+            Assert.AreEqual(3, MathHelper.NumberOfDigits(100));
+            Assert.AreEqual(4, MathHelper.NumberOfDigits(1000));
+            Assert.AreEqual(5, MathHelper.NumberOfDigits(10000));
+        }
+
+        [TestMethod]
+        public void NumberOfDigits_BoundaryValues_NineAndTen()
+        {
+            Assert.AreEqual(1, MathHelper.NumberOfDigits(9));
+            Assert.AreEqual(2, MathHelper.NumberOfDigits(10));
+        }
+
+        [TestMethod]
+        public void NumberOfDigits_BoundaryValues_NinetyNineAndHundred()
+        {
+            Assert.AreEqual(2, MathHelper.NumberOfDigits(99));
+            Assert.AreEqual(3, MathHelper.NumberOfDigits(100));
+        }
+
+        #endregion
+    }
+}

src/modules/peek/Peek.Common.UnitTests/PathHelperTests.cs

@@ -0,0 +1,98 @@
+// Copyright (c) Microsoft Corporation
+// The Microsoft Corporation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+using Peek.Common.Helpers;
+
+namespace Peek.Common.UnitTests
+{
+    [TestClass]
+    public class PathHelperTests
+    {
+        #region UNC Paths - Should return true
+
+        [TestMethod]
+        public void IsUncPath_StandardUncPath_ShouldReturnTrue()
+        {
+            Assert.IsTrue(PathHelper.IsUncPath(@"\\server\share"));
+        }
+
+        [TestMethod]
+        public void IsUncPath_UncPathWithSubfolder_ShouldReturnTrue()
+        {
+            Assert.IsTrue(PathHelper.IsUncPath(@"\\server\share\folder\file.txt"));
+        }
+
+        [TestMethod]
+        public void IsUncPath_UncPathWithDottedServer_ShouldReturnTrue()
+        {
+            Assert.IsTrue(PathHelper.IsUncPath(@"\\server.domain.com\share"));
+        }
+
+        [TestMethod]
+        public void IsUncPath_UncPathWithIPAddress_ShouldReturnTrue()
+        {
+            Assert.IsTrue(PathHelper.IsUncPath(@"\\192.168.1.1\share"));
+        }
+
+        #endregion
+
+        #region Local Paths - Should return false
+
+        [TestMethod]
+        public void IsUncPath_LocalDrivePath_ShouldReturnFalse()
+        {
+            Assert.IsFalse(PathHelper.IsUncPath(@"C:\Users\test\file.txt"));
+        }
+
+        [TestMethod]
+        public void IsUncPath_LocalRootPath_ShouldReturnFalse()
+        {
+            Assert.IsFalse(PathHelper.IsUncPath(@"D:\"));
+        }
+
+        [TestMethod]
+        public void IsUncPath_RelativePath_ShouldReturnFalse()
+        {
+            Assert.IsFalse(PathHelper.IsUncPath(@"folder\file.txt"));
+        }
+
+        #endregion
+
+        #region Edge Cases
+
+        [TestMethod]
+        public void IsUncPath_EmptyString_ShouldReturnFalse()
+        {
+            Assert.IsFalse(PathHelper.IsUncPath(string.Empty));
+        }
+
+        [TestMethod]
+        public void IsUncPath_HttpUrl_ShouldReturnFalse()
+        {
+            Assert.IsFalse(PathHelper.IsUncPath("http://example.com/path"));
+        }
+
+        [TestMethod]
+        public void IsUncPath_FileUri_ShouldReturnFalse()
+        {
+            Assert.IsFalse(PathHelper.IsUncPath("file:///C:/Users/test/file.txt"));
+        }
+
+        [TestMethod]
+        public void IsUncPath_UncFileUri_ShouldReturnTrue()
+        {
+            // file://server/share is a UNC URI
+            Assert.IsTrue(PathHelper.IsUncPath(@"\\server\share\file.txt"));
+        }
+
+        [TestMethod]
+        public void IsUncPath_SingleBackslash_ShouldReturnFalse()
+        {
+            Assert.IsFalse(PathHelper.IsUncPath(@"\server\share"));
+        }
+
+        #endregion
+    }
+}

src/modules/peek/Peek.Common.UnitTests/Peek.Common.UnitTests.csproj

@@ -0,0 +1,23 @@
+<Project Sdk="Microsoft.NET.Sdk">
+  <!-- Look at Directory.Build.props in root for common stuff as well -->
+  <Import Project="$(RepoRoot)src\Common.Dotnet.CsWinRT.props" />
+
+  <PropertyGroup>
+    <IsPackable>false</IsPackable>
+    <AppendTargetFrameworkToOutputPath>false</AppendTargetFrameworkToOutputPath>
+    <AppendRuntimeIdentifierToOutputPath>false</AppendRuntimeIdentifierToOutputPath>
+    <OutputPath>$(SolutionDir)$(Platform)\$(Configuration)\tests\Peek.Common.Tests\</OutputPath>
+    <RootNamespace>Peek.Common.UnitTests</RootNamespace>
+    <AssemblyName>PowerToys.Peek.Common.UnitTests</AssemblyName>
+    <OutputType>Exe</OutputType>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <PackageReference Include="MSTest" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <ProjectReference Include="..\Peek.Common\Peek.Common.csproj" />
+  </ItemGroup>
+
+</Project>