Add tests for maui

.gitignore

@@ -328,3 +328,8 @@ ASALocalRun/
 
 # MFractors (Xamarin productivity tool) working folder 
 .mfractor/
+
+
+#dont save code coverage results
+coverage.opencover.xml
+coverage.json

src/Caliburn.Micro.Maui.Tests/ActionMessageTests.cs

@@ -0,0 +1,49 @@
+namespace Caliburn.Micro.Maui.Tests
+{
+    public class ActionMessageTests
+    {
+        [Fact]
+        public void MethodName_ShouldBeSetAndRetrievedCorrectly()
+        {
+            // Arrange
+            var actionMessage = new ActionMessage();
+            var expectedMethodName = "TestMethod";
+
+            // Act
+            actionMessage.MethodName = expectedMethodName;
+            var actualMethodName = actionMessage.MethodName;
+
+            // Assert
+            Assert.Equal(expectedMethodName, actualMethodName);
+        }
+
+        [Fact]
+        public void Handler_ShouldBeSetAndRetrievedCorrectly()
+        {
+            // Arrange
+            var actionMessage = new ActionMessage();
+            var expectedHandler = new object();
+
+            // Act
+            actionMessage.Handler = expectedHandler;
+            var actualHandler = actionMessage.Handler;
+
+            // Assert
+            Assert.Equal(expectedHandler, actualHandler);
+        }
+
+        [Fact]
+        public void Parameters_ShouldBeInitialized()
+        {
+            // Arrange
+            var actionMessage = new ActionMessage();
+
+            // Act
+            var parameters = actionMessage.Parameters;
+
+            // Assert
+            Assert.NotNull(parameters);
+        }
+
+    }
+}

src/Caliburn.Micro.Maui.Tests/AssemblyCacheTests.cs

@@ -0,0 +1,34 @@
+namespace Caliburn.Micro.Maui.Tests
+{
+    public class AssemblyCacheTests
+    {
+        [Fact]
+        public void AddingTheSameAssemblyMoreThanOneShouldNotThrow()
+        {
+            AssemblySourceCache.Install();
+
+            var testAssembly = typeof(AssemblyCacheTests).Assembly;
+            AssemblySource.Instance.Add(testAssembly);
+
+            //Re-add the same assembly
+            var exception = Record.Exception(() => AssemblySource.Instance.Add(testAssembly));
+            Assert.Null(exception);
+        }
+
+        [Fact]
+        public void ResettingTheCacheWithMoreThanOneAssemblyShouldNotThrow()
+        {
+            AssemblySourceCache.Install();
+
+            var testAssembly = typeof(AssemblyCacheTests).Assembly;
+
+            AssemblySource.Instance.AddRange(new[] { testAssembly, testAssembly });
+
+            //Refresh clears and re-creates the cache
+            var exception = Record.Exception(() => AssemblySource.Instance.Refresh());
+            Assert.Null(exception);
+        }
+    }
+
+
+}

src/Caliburn.Micro.Maui.Tests/Caliburn.Micro.Maui.Tests.csproj

@@ -0,0 +1,37 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <TargetFramework>net8.0</TargetFramework>
+    <ImplicitUsings>enable</ImplicitUsings>
+    <Nullable>enable</Nullable>
+    <UseMaui>true</UseMaui>
+    <IsPackable>false</IsPackable>
+    <IsTestProject>true</IsTestProject>
+  </PropertyGroup>
+  <PropertyGroup>
+    <LangVersion>10.0</LangVersion>
+  </PropertyGroup>
+  <ItemGroup>
+    <PackageReference Include="coverlet.collector" Version="6.0.0" />
+    <PackageReference Include="Microsoft.Maui.Controls" Version="8.0.92" />
+    <PackageReference Include="Microsoft.Maui.Controls.Compatibility" Version="8.0.92" />
+    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.8.0" />
+    <PackageReference Include="Moq" Version="4.20.72" />
+    <PackageReference Include="xunit" Version="2.9.2" />
+    <PackageReference Include="xunit.runner.visualstudio" Version="2.8.2">
+      <PrivateAssets>all</PrivateAssets>
+      <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
+    </PackageReference>
+  </ItemGroup>
+
+  <ItemGroup>
+    <ProjectReference Include="..\Caliburn.Micro.Core\Caliburn.Micro.Core.csproj" />
+    <ProjectReference Include="..\Caliburn.Micro.Maui\Caliburn.Micro.Maui.csproj" />
+    <ProjectReference Include="..\Caliburn.Micro.Platform.Core\Caliburn.Micro.Platform.Core.csproj" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <Using Include="Xunit" />
+  </ItemGroup>
+
+</Project>

src/Caliburn.Micro.Maui.Tests/FormsPlatformProviderTests.cs

@@ -0,0 +1,126 @@
+using Moq;
+
+namespace Caliburn.Micro.Maui.Tests
+{
+    public class FormsPlatformProviderTests
+    {
+        private readonly Mock<IPlatformProvider> mockPlatformProvider;
+        private readonly FormsPlatformProvider formsPlatformProvider;
+
+        public FormsPlatformProviderTests()
+        {
+            mockPlatformProvider = new Mock<IPlatformProvider>();
+            formsPlatformProvider = new FormsPlatformProvider(mockPlatformProvider.Object);
+        }
+
+        [Fact]
+        public void InDesignMode_ShouldReturnPlatformProviderInDesignMode()
+        {
+            // Arrange
+            mockPlatformProvider.Setup(p => p.InDesignMode).Returns(true);
+
+            // Act
+            var result = formsPlatformProvider.InDesignMode;
+
+            // Assert
+            Assert.True(result);
+        }
+
+        [Fact]
+        public void PropertyChangeNotificationsOnUIThread_ShouldReturnPlatformProviderPropertyChangeNotificationsOnUIThread()
+        {
+            // Arrange
+            mockPlatformProvider.Setup(p => p.PropertyChangeNotificationsOnUIThread).Returns(true);
+
+            // Act
+            var result = formsPlatformProvider.PropertyChangeNotificationsOnUIThread;
+
+            // Assert
+            Assert.True(result);
+        }
+
+        [Fact]
+        public void BeginOnUIThread_ShouldCallPlatformProviderBeginOnUIThread()
+        {
+            // Arrange
+            System.Action action = () => { };
+
+            // Act
+            formsPlatformProvider.BeginOnUIThread(action);
+
+            // Assert
+            mockPlatformProvider.Verify(p => p.BeginOnUIThread(action), Times.Once);
+        }
+
+        [Fact]
+        public async Task OnUIThreadAsync_ShouldCallPlatformProviderOnUIThreadAsync()
+        {
+            // Arrange
+            Func<Task> action = async () => await Task.CompletedTask;
+
+            // Act
+            await formsPlatformProvider.OnUIThreadAsync(action);
+
+            // Assert
+            mockPlatformProvider.Verify(p => p.OnUIThreadAsync(action), Times.Once);
+        }
+
+        [Fact]
+        public void OnUIThread_ShouldCallPlatformProviderOnUIThread()
+        {
+            // Arrange
+            System.Action action = () => { };
+
+            // Act
+            formsPlatformProvider.OnUIThread(action);
+
+            // Assert
+            mockPlatformProvider.Verify(p => p.OnUIThread(action), Times.Once);
+        }
+
+        [Fact]
+        public void ExecuteOnFirstLoad_ShouldCallPlatformProviderExecuteOnFirstLoad_WhenViewIsNotPage()
+        {
+            // Arrange
+            var view = new object();
+            Action<object> handler = _ => { };
+
+            // Act
+            formsPlatformProvider.ExecuteOnFirstLoad(view, handler);
+
+            // Assert
+            mockPlatformProvider.Verify(p => p.ExecuteOnFirstLoad(view, handler), Times.Once);
+        }
+
+
+        [Fact]
+        public void ExecuteOnLayoutUpdated_ShouldCallPlatformProviderExecuteOnLayoutUpdated()
+        {
+            // Arrange
+            var view = new object();
+            Action<object> handler = _ => { };
+
+            // Act
+            formsPlatformProvider.ExecuteOnLayoutUpdated(view, handler);
+
+            // Assert
+            mockPlatformProvider.Verify(p => p.ExecuteOnLayoutUpdated(view, handler), Times.Once);
+        }
+
+        [Fact]
+        public void GetViewCloseAction_ShouldCallPlatformProviderGetViewCloseAction()
+        {
+            // Arrange
+            var viewModel = new object();
+            var views = new List<object>();
+            bool? dialogResult = true;
+
+            // Act
+            formsPlatformProvider.GetViewCloseAction(viewModel, views, dialogResult);
+
+            // Assert
+            mockPlatformProvider.Verify(p => p.GetViewCloseAction(viewModel, views, dialogResult), Times.Once);
+        }
+    }
+
+}

src/Caliburn.Micro.Maui.Tests/MessageBinderTests.cs

@@ -0,0 +1,17 @@
+namespace Caliburn.Micro.Maui.Tests
+{
+    public class MessageBinderTests
+    {
+        [Fact]
+        public void EvaluateParameterCaseInsensitive()
+        {
+            MessageBinder.SpecialValues.Add("$sampleParameter", context => 42);
+            var caseSensitiveValue = MessageBinder.EvaluateParameter("$sampleParameter", typeof(int), new ActionExecutionContext());
+
+            Assert.NotEqual("$sampleParameter", caseSensitiveValue);
+
+            var caseInsensitiveValue = MessageBinder.EvaluateParameter("$sampleparameter", typeof(int), new ActionExecutionContext());
+            Assert.NotEqual("$sampleparameter", caseInsensitiveValue);
+        }
+    }
+}

src/Caliburn.Micro.Maui.Tests/ParameterTests.cs

@@ -0,0 +1,90 @@
+namespace Caliburn.Micro.Maui.Tests
+{
+    using Microsoft.Maui.Controls;
+    using Moq;
+    using Xunit;
+
+
+    public class ParameterTests
+    {
+        [Fact]
+        public void ValueProperty_Should_SetAndGetValue()
+        {
+            // Arrange
+            var parameter = new Parameter();
+            var expectedValue = "TestValue";
+
+            // Act
+            parameter.Value = expectedValue;
+            var actualValue = parameter.Value;
+
+            // Assert
+            Assert.Equal(expectedValue, actualValue);
+        }
+
+        [Fact]
+        public void Attach_Should_SetAssociatedObject()
+        {
+            // Arrange
+            var parameter = new Parameter();
+            var bindableObject = new CheckBox();
+
+            // Act
+            ((IAttachedObject)parameter).Attach(bindableObject);
+
+            // Assert
+            Assert.Equal(bindableObject, ((IAttachedObject)parameter).AssociatedObject);
+        }
+
+        [Fact]
+        public void Detach_Should_ClearAssociatedObject()
+        {
+            // Arrange
+            var parameter = new Parameter();
+            var bindableObject = new TextCell();
+            ((IAttachedObject)parameter).Attach(bindableObject);
+
+            // Act
+            ((IAttachedObject)parameter).Detach();
+
+            // Assert
+            Assert.Null(((IAttachedObject)parameter).AssociatedObject);
+        }
+
+        [Fact]
+        public void OnValueChanged_Should_UpdateAvailability()
+        {
+            // Arrange
+            var parameter = new Parameter();
+            var mockActionMessage = new Mock<ActionMessage>();
+            mockActionMessage.Setup(x => x.UpdateAvailability());
+            var actionMessage = mockActionMessage.Object;
+            parameter.MakeAwareOf(actionMessage);
+
+            // Act
+            Parameter.OnValueChanged(parameter, new DependencyPropertyChangedEventArgs(null, null, Parameter.ValueProperty));
+
+            // Assert
+            mockActionMessage.Verify(v => v.UpdateAvailability());
+        }
+
+
+        [Fact]
+        public void ExecuteOnFirstLoad_ShouldCallBaseMethod_WhenViewIsNotPage()
+        {
+            // Arrange
+            var mockPlatformProvider = new Mock<IPlatformProvider>();
+            var formsPlatformProvider = new FormsPlatformProvider(mockPlatformProvider.Object);
+            var mockView = new Mock<object>();
+            Action<object> handler = (view) => { };
+
+            // Act
+            formsPlatformProvider.ExecuteOnFirstLoad(mockView.Object, handler);
+
+            // Assert
+            mockPlatformProvider.Verify(p => p.ExecuteOnFirstLoad(mockView.Object, handler), Times.Once);
+        }
+    }
+
+
+}

src/Caliburn.Micro.Maui.Tests/ParserTests.cs

@@ -0,0 +1,19 @@
+using System.Globalization;
+
+namespace Caliburn.Micro.Maui.Tests
+{
+    public class ParserTests
+    {
+        [Fact]
+        public void CreateParametersWithOddNumbers()
+        {
+            var evenResult = Parser.CreateParameter(null, "0.1");
+            var oddResult = Parser.CreateParameter(null, "-0.1");
+            var nanResult = Parser.CreateParameter(null, "-0.1abc");
+
+            Assert.Equal(0.1, double.Parse((string)evenResult.Value, CultureInfo.InvariantCulture));
+            Assert.Equal(-0.1, double.Parse((string)oddResult.Value, CultureInfo.InvariantCulture));
+            Assert.Null(nanResult.Value);
+        }
+    }
+}