Merge pull request #47 from NavneetHegde/release/3.2

Release/3.2

Author: NavneetHegde

.github/workflows/nuget-publish.yml

@@ -8,39 +8,46 @@ on:
       - 'v*'
 
 jobs: 
-   build-and-publish:
-    runs-on: ubuntu-latest
+  build-and-test:
+    runs-on: ubuntu-22.04  # or ubuntu-latest if using include-runtime
     permissions:
       id-token: write # enable GitHub OIDC token issuance for this job
+    strategy:
+      matrix:
+        dotnet-version: [8.x, 9.x] # test all supported versions
     steps:
     - name: Checkout code
       uses: actions/checkout@v4
 
-    - name: Setup .NET
+    - name: Setup .NET SDK and runtime
       uses: actions/setup-dotnet@v4
       with:
-        dotnet-version: '9.0.x'
+        dotnet-version: ${{ matrix.dotnet-version }}
 
     - name: Restore dependencies
       run: dotnet restore
 
     - name: Build
       run: dotnet build --configuration Release --no-restore
 
-    - name: Test
-      run: dotnet test --configuration Release --no-build --verbosity normal
+    - name: Run Tests
+      run: dotnet test --configuration Release --no-build --verbosity normal -maxcpucount:1
 
     - name: Pack
+      if: matrix.dotnet-version == '9.x'
       run: dotnet pack --configuration Release --no-build --output ./nupkg
 
     - name: Nuget Login (OIDC + temp API Key)  
+      if: matrix.dotnet-version == '9.x'
       uses: Nuget/login@v1
       id: login
       with:
         user: ${{secrets.NUGET_USER}}
 
     - name: Nuget push
+      if: matrix.dotnet-version == '9.x'
       run: dotnet nuget push nupkg/*.nupkg --api-key ${{steps.login.outputs.NUGET_API_KEY}} --source https://api.nuget.org/v3/index.json
 
-  
+    - name: Done
+      run: echo "Package published successfully!"
 

OpenCode.Tests/BoolExtension/BoolExtension.Core.UnitTest.cs

@@ -0,0 +1,42 @@
+using Xunit;
+
+namespace OpenCode.Tests;
+
+public class BoolExtensionTests
+{
+    [Theory]
+    [InlineData(true, "Yes")]
+    [InlineData(false, "No")]
+    public void ToYesNo_ReturnsExpectedString(bool input, string expected)
+    {
+        var result = input.ToYesNo();
+        Assert.Equal(expected, result);
+    }
+
+    [Theory]
+    [InlineData(true, "True")]
+    [InlineData(false, "False")]
+    public void ToTitleCase_ReturnsExpectedString(bool input, string expected)
+    {
+        var result = input.ToTitleCase();
+        Assert.Equal(expected, result);
+    }
+
+    [Theory]
+    [InlineData(true, 1)]
+    [InlineData(false, 0)]
+    public void ToInt_ReturnsExpectedInteger(bool input, int expected)
+    {
+        var result = input.ToInt();
+        Assert.Equal(expected, result);
+    }
+
+    [Theory]
+    [InlineData(true, "true")]
+    [InlineData(false, "false")]
+    public void ToLowerString_ReturnsExpectedString(bool input, string expected)
+    {
+        var result = input.ToLowerString();
+        Assert.Equal(expected, result);
+    }
+}

OpenCode.Tests/DateTimeExtension/DateTimeExtension.UnitTest.cs

@@ -0,0 +1,73 @@
+using System;
+using Xunit;
+
+namespace OpenCode.Tests;
+
+public class DateTimeExtensionTests
+{
+    [Theory]
+    [InlineData("2025-10-21 15:30:00", "yyyy-MM-dd HH:mm:ss", "2025-10-21 15:30:00")]
+    [InlineData("2025-10-21 15:30:00", "MM/dd/yyyy", "10/21/2025")]
+    public void ToFormat_ReturnsExpectedString(string dateStr, string format, string expected)
+    {
+        var date = DateTime.Parse(dateStr);
+        var result = date.ToFormat(format);
+        Assert.Equal(expected, result);
+    }
+
+    [Theory]
+    [InlineData(DayOfWeek.Monday, false)]
+    [InlineData(DayOfWeek.Tuesday, false)]
+    [InlineData(DayOfWeek.Wednesday, false)]
+    [InlineData(DayOfWeek.Thursday, false)]
+    [InlineData(DayOfWeek.Friday, false)]
+    [InlineData(DayOfWeek.Saturday, true)]
+    [InlineData(DayOfWeek.Sunday, true)]
+    public void IsWeekend_ReturnsCorrectResult(DayOfWeek dayOfWeek, bool expected)
+    {
+        var date = new DateTime(2025, 10, 20).AddDays((int)dayOfWeek - (int)DayOfWeek.Monday);
+        var result = date.IsWeekend();
+        Assert.Equal(expected, result);
+    }
+
+    [Fact]
+    public void IsToday_ReturnsTrueForToday()
+    {
+        var today = DateTime.Today.AddHours(10);
+        Assert.True(today.IsToday());
+    }
+
+    [Fact]
+    public void IsToday_ReturnsFalseForOtherDate()
+    {
+        var yesterday = DateTime.Today.AddDays(-1);
+        Assert.False(yesterday.IsToday());
+    }
+
+    [Fact]
+    public void StartOfDay_ReturnsMidnight()
+    {
+        var date = new DateTime(2025, 10, 21, 15, 30, 45);
+        var start = date.StartOfDay();
+        Assert.Equal(new DateTime(2025, 10, 21, 0, 0, 0), start);
+    }
+
+    [Fact]
+    public void EndOfDay_ReturnsEndOfDay()
+    {
+        var date = new DateTime(2025, 10, 21, 15, 30, 45);
+        var end = date.EndOfDay();
+        Assert.Equal(new DateTime(2025, 10, 21, 23, 59, 59, 999), end);
+    }
+
+    [Theory]
+    [InlineData("2000-10-21", 25)] // assuming test is run in 2025
+    [InlineData("2020-10-21", 5)]
+    [InlineData("2025-10-21", 0)]
+    public void ToAge_ReturnsExpectedAge(string birthDateStr, int expectedAge)
+    {
+        var birthDate = DateTime.Parse(birthDateStr);
+        var result = birthDate.ToAge();
+        Assert.Equal(expectedAge, result);
+    }
+}

OpenCode.Tests/DecimalExtension/DecimalExtension.UnitTest.cs

@@ -0,0 +1,58 @@
+using System.Globalization;
+using Xunit;
+
+namespace OpenCode.Tests;
+
+public class DecimalExtensionTests
+{
+    [Theory]
+    [InlineData(12.3456, 2, 12.35)]
+    [InlineData(12.344, 2, 12.34)]
+    [InlineData(-12.345, 1, -12.3)]
+    public void RoundTo_ReturnsExpectedDecimal(decimal value, int decimals, decimal expected)
+    {
+        var result = value.RoundTo(decimals);
+        Assert.Equal(expected, result);
+    }
+
+    [Theory]
+    [InlineData(12345.678, "N2", "12,345.68")]
+    [InlineData(12345.678, "N0", "12,346")]
+    [InlineData(12345.678, "C", "$12,345.68")] // using InvariantCulture will prefix with "¤"
+    public void ToMoneyFormat_ReturnsExpectedString(decimal value, string format, string expected)
+    {
+        var result = value.ToMoneyFormat(format, CultureInfo.GetCultureInfo("en-US"));
+        Assert.Equal(expected, result);
+    }
+
+    [Theory]
+    [InlineData(1.0000, 1.00005, true)]
+    [InlineData(1.0000, 1.0002, false)]
+    [InlineData(-1.0000, -1.00009, true)]
+    public void AlmostEquals_ReturnsExpectedResult(decimal a, decimal b, bool expected)
+    {
+        var result = a.AlmostEquals(b);
+        Assert.Equal(expected, result);
+    }
+
+    [Theory]
+    [InlineData(0.25, 0, "25%")]
+    [InlineData(0.2567, 1, "25.7%")]
+    [InlineData(1, 0, "100%")]
+    public void ToPercentage_ReturnsExpectedString(decimal value, int decimals, string expected)
+    {
+        var result = value.ToPercentage(decimals);
+        Assert.Equal(expected, result);
+    }
+
+    [Theory]
+    [InlineData(12.34, "en-US", "$12.34")]
+    [InlineData(12.34, "fr-FR", "12,34 €")]
+    [InlineData(12.34, "ja-JP", "￥12")]
+    public void ToCurrency_ReturnsExpectedString(decimal value, string cultureName, string expected)
+    {
+        var culture = CultureInfo.GetCultureInfo(cultureName);
+        var result = value.ToCurrency(culture);
+        Assert.Equal(expected, result);
+    }
+}

OpenCode.Tests/GuidExtension/GuidExtension.UnitTest.cs

@@ -0,0 +1,67 @@
+using System;
+using Xunit;
+
+namespace OpenCode.Tests;
+
+public class GuidExtensionTests
+{
+    [Fact]
+    public void IsNotEmpty_ReturnsTrueForNonEmptyGuid()
+    {
+        var guid = Guid.NewGuid();
+        Assert.True(guid.IsNotEmpty());
+    }
+
+    [Fact]
+    public void IsNotEmpty_ReturnsFalseForEmptyGuid()
+    {
+        var guid = Guid.Empty;
+        Assert.False(guid.IsNotEmpty());
+    }
+
+    [Fact]
+    public void IsEmpty_ReturnsTrueForEmptyGuid()
+    {
+        var guid = Guid.Empty;
+        Assert.True(guid.IsEmpty());
+    }
+
+    [Fact]
+    public void IsEmpty_ReturnsFalseForNonEmptyGuid()
+    {
+        var guid = Guid.NewGuid();
+        Assert.False(guid.IsEmpty());
+    }
+
+    [Fact]
+    public void ToCompactString_RemovesHyphens()
+    {
+        var guid = Guid.Parse("12345678-1234-1234-1234-1234567890ab");
+        var result = guid.ToCompactString();
+        Assert.Equal("123456781234123412341234567890ab", result);
+    }
+
+    [Fact]
+    public void ToShortGuid_Returns22CharacterString()
+    {
+        var guid = Guid.NewGuid();
+        var result = guid.ToShortGuid();
+
+        Assert.Equal(22, result.Length);
+        // Ensure no '/' or '+' characters
+        Assert.DoesNotContain("/", result);
+        Assert.DoesNotContain("+", result);
+    }
+
+    [Fact]
+    public void ToShortGuid_UniqueForDifferentGuids()
+    {
+        var guid1 = Guid.NewGuid();
+        var guid2 = Guid.NewGuid();
+
+        var short1 = guid1.ToShortGuid();
+        var short2 = guid2.ToShortGuid();
+
+        Assert.NotEqual(short1, short2);
+    }
+}

OpenCode.Tests/IntegerExtension/IntegerExtension.UnitTest.cs

@@ -0,0 +1,66 @@
+using Xunit;
+
+namespace OpenCode.Tests;
+
+public class IntegerExtensionTests
+{
+    [Theory]
+    [InlineData(2, true)]
+    [InlineData(4, true)]
+    [InlineData(1, false)]
+    [InlineData(-2, true)]
+    [InlineData(-3, false)]
+    public void IsEven_ReturnsExpectedResult(int value, bool expected)
+    {
+        Assert.Equal(expected, value.IsEven());
+    }
+
+    [Theory]
+    [InlineData(1, true)]
+    [InlineData(3, true)]
+    [InlineData(2, false)]
+    [InlineData(-1, true)]
+    [InlineData(-4, false)]
+    public void IsOdd_ReturnsExpectedResult(int value, bool expected)
+    {
+        Assert.Equal(expected, value.IsOdd());
+    }
+
+    [Theory]
+    [InlineData(1, "1st")]
+    [InlineData(2, "2nd")]
+    [InlineData(3, "3rd")]
+    [InlineData(4, "4th")]
+    [InlineData(11, "11th")]
+    [InlineData(12, "12th")]
+    [InlineData(13, "13th")]
+    [InlineData(21, "21st")]
+    [InlineData(22, "22nd")]
+    [InlineData(23, "23rd")]
+    [InlineData(101, "101st")]
+    public void ToOrdinal_ReturnsExpectedString(int number, string expected)
+    {
+        Assert.Equal(expected, number.ToOrdinal());
+    }
+
+    [Theory]
+    [InlineData(5, 1, 10, 5)]
+    [InlineData(0, 1, 10, 1)]
+    [InlineData(15, 1, 10, 10)]
+    [InlineData(-5, -10, 0, -5)]
+    [InlineData(-15, -10, 0, -10)]
+    public void Clamp_ReturnsValueWithinRange(int value, int min, int max, int expected)
+    {
+        Assert.Equal(expected, value.Clamp(min, max));
+    }
+
+    [Theory]
+    [InlineData(5, 5)]
+    [InlineData(-5, 5)]
+    [InlineData(0, 0)]
+    [InlineData(-123, 123)]
+    public void Abs_ReturnsAbsoluteValue(int value, int expected)
+    {
+        Assert.Equal(expected, value.Abs());
+    }
+}

OpenCode.Tests/OpenCode.Tests.csproj

@@ -1,9 +1,10 @@
 <Project Sdk="Microsoft.NET.Sdk">
 
   <PropertyGroup>
-    <TargetFramework>NET9.0</TargetFramework>
-    <IsPackable>false</IsPackable>
-  </PropertyGroup>
+		<TargetFrameworks>net8.0;net9.0</TargetFrameworks>
+		<IsPackable>false</IsPackable>
+		<Nullable>enable</Nullable>
+	</PropertyGroup>
 
   <ItemGroup>
     <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.13.0" />