Update tests

Author: ChrisPulman

src/ReactiveUI.Uno.Tests/Converters/BooleanToVisibilityTypeConverterTests.cs

@@ -4,56 +4,75 @@
 // See the LICENSE file in the project root for full license information.
 
 using FluentAssertions;
-using Xunit;
-#if HAS_WINUI
 using Microsoft.UI.Xaml;
-#else
-using Windows.UI.Xaml;
-#endif
+using NUnit.Framework;
 
 namespace ReactiveUI.Uno.Tests.Converters;
 
+/// <summary>
+/// BooleanToVisibilityTypeConverterTests.
+/// </summary>
+[TestFixture]
 public class BooleanToVisibilityTypeConverterTests
 {
     private readonly BooleanToVisibilityTypeConverter _sut = new();
 
-    [Fact]
+    /// <summary>
+    /// Affinities the is high for bool to visibility.
+    /// </summary>
+    [Test]
     public void Affinity_is_high_for_bool_to_visibility()
     {
         _sut.GetAffinityForObjects(typeof(bool), typeof(Visibility)).Should().Be(10);
         _sut.GetAffinityForObjects(typeof(Visibility), typeof(bool)).Should().Be(10);
     }
 
-    [Theory]
-    [InlineData(true, Visibility.Visible)]
-    [InlineData(false, Visibility.Collapsed)]
+    /// <summary>
+    /// Convertses the bool to visibility.
+    /// </summary>
+    /// <param name="input">if set to <c>true</c> [input].</param>
+    /// <param name="expected">The expected.</param>
+    [TestCase(true, Visibility.Visible)]
+    [TestCase(false, Visibility.Collapsed)]
     public void Converts_bool_to_visibility(bool input, Visibility expected)
     {
         _sut.TryConvert(input, typeof(Visibility), BooleanToVisibilityHint.None, out var result).Should().BeTrue();
         result.Should().Be(expected);
     }
 
-    [Theory]
-    [InlineData(true, Visibility.Collapsed)]
-    [InlineData(false, Visibility.Visible)]
+    /// <summary>
+    /// Convertses the bool to visibility inverse.
+    /// </summary>
+    /// <param name="input">if set to <c>true</c> [input].</param>
+    /// <param name="expected">The expected.</param>
+    [TestCase(true, Visibility.Collapsed)]
+    [TestCase(false, Visibility.Visible)]
     public void Converts_bool_to_visibility_inverse(bool input, Visibility expected)
     {
         _sut.TryConvert(input, typeof(Visibility), BooleanToVisibilityHint.Inverse, out var result).Should().BeTrue();
         result.Should().Be(expected);
     }
 
-    [Theory]
-    [InlineData(Visibility.Visible, true)]
-    [InlineData(Visibility.Collapsed, false)]
+    /// <summary>
+    /// Convertses the visibility to bool.
+    /// </summary>
+    /// <param name="input">The input.</param>
+    /// <param name="expected">if set to <c>true</c> [expected].</param>
+    [TestCase(Visibility.Visible, true)]
+    [TestCase(Visibility.Collapsed, false)]
     public void Converts_visibility_to_bool(Visibility input, bool expected)
     {
         _sut.TryConvert(input, typeof(bool), BooleanToVisibilityHint.None, out var result).Should().BeTrue();
         result.Should().Be(expected);
     }
 
-    [Theory]
-    [InlineData(Visibility.Visible, false)]
-    [InlineData(Visibility.Collapsed, true)]
+    /// <summary>
+    /// Convertses the visibility to bool inverse.
+    /// </summary>
+    /// <param name="input">The input.</param>
+    /// <param name="expected">if set to <c>true</c> [expected].</param>
+    [TestCase(Visibility.Visible, false)]
+    [TestCase(Visibility.Collapsed, true)]
     public void Converts_visibility_to_bool_inverse(Visibility input, bool expected)
     {
         _sut.TryConvert(input, typeof(bool), BooleanToVisibilityHint.Inverse, out var result).Should().BeTrue();

src/ReactiveUI.Uno.Tests/Hooks/AutoDataTemplateBindingHookTests.cs

@@ -3,46 +3,72 @@
 // The reactiveui and contributors licenses this file to you under the MIT license.
 // See the LICENSE file in the project root for full license information.
 
+using System.Linq.Expressions;
 using FluentAssertions;
-using ReactiveUI;
-using Xunit;
-#if HAS_WINUI
-using Microsoft.UI.Xaml;
 using Microsoft.UI.Xaml.Controls;
-#else
-using Windows.UI.Xaml;
-using Windows.UI.Xaml.Controls;
-#endif
+using NUnit.Framework;
 
-namespace ReactiveUI.Uno.Tests.Hooks;
+namespace ReactiveUI.Uno.Tests;
 
+/// <summary>
+/// AutoDataTemplateBindingHookTests.
+/// </summary>
+[TestFixture]
 public class AutoDataTemplateBindingHookTests
 {
-    private class TestViewModel
+    /// <summary>
+    /// Executes the hook sets default template when eligible.
+    /// </summary>
+    [Test]
+    public void ExecuteHook_Sets_DefaultTemplate_When_Eligible()
     {
-    }
+        var hook = new AutoDataTemplateBindingHook();
+        ItemsControl ic;
+        try
+        {
+            ic = new ItemsControl();
+        }
+        catch (System.Exception ex) when (ex is System.TypeInitializationException || ex is System.NotSupportedException)
+        {
+            Assert.Ignore("UI dispatcher not available for Uno/WinUI controls in this environment.");
+            return;
+        }
 
-    [Fact]
-    public void Sets_default_item_template_when_binding_items_source()
-    {
-        // Arrange
-        var hook = new ReactiveUI.Uno.AutoDataTemplateBindingHook();
-        var items = new ItemsControl();
+        var vmChanges = Array.Empty<IObservedChange<object, object>>();
+        var expr = (Expression<System.Func<object?>>)(() => ic.ItemsSource);
+        var viewChanges = new[]
+        {
+            new ObservedChange<object, object>(ic, expr, new object())
+        };
 
-        // Build a member access expression body: x => x.ItemsSource
-        var parameter = System.Linq.Expressions.Expression.Parameter(typeof(ItemsControl), "x");
-        var body = System.Linq.Expressions.Expression.Property(parameter, nameof(ItemsControl.ItemsSource));
+        var result = hook.ExecuteHook(null, ic, () => vmChanges, () => viewChanges, BindingDirection.OneWay);
+        result.Should().BeTrue();
+        ic.ItemTemplate.Should().NotBeNull();
+    }
 
-        var change = new ObservedChange<object, object>(items, body, default!);
+    /// <summary>
+    /// Executes the hook does not override existing template.
+    /// </summary>
+    [Test]
+    public void ExecuteHook_Does_Not_Override_Existing_Template()
+    {
+        var hook = new AutoDataTemplateBindingHook();
+        ItemsControl ic;
+        try
+        {
+            ic = new ItemsControl { ItemTemplate = AutoDataTemplateBindingHook.DefaultItemTemplate.Value };
+        }
+        catch (System.Exception ex) when (ex is System.TypeInitializationException || ex is System.NotSupportedException)
+        {
+            Assert.Ignore("UI dispatcher not available for Uno/WinUI controls in this environment.");
+            return;
+        }
 
-        // Act
-        var ok = hook.ExecuteHook(null, items,
-            () => System.Array.Empty<IObservedChange<object, object>>(),
-            () => new[] { change },
-            default);
+        var expr = (Expression<System.Func<object?>>)(() => ic.ItemsSource);
+        var viewChanges = new[] { new ObservedChange<object, object>(ic, expr, new object()) };
 
-        // Assert
-        ok.Should().BeTrue();
-        items.ItemTemplate.Should().NotBeNull();
+        var result = hook.ExecuteHook(null, ic, Array.Empty<IObservedChange<object, object>>, () => viewChanges, BindingDirection.OneWay);
+        result.Should().BeTrue();
+        ic.ItemTemplate.Should().NotBeNull();
     }
 }

src/ReactiveUI.Uno.Tests/Platform/PlatformOperationsTests.cs

@@ -4,13 +4,20 @@
 // See the LICENSE file in the project root for full license information.
 
 using FluentAssertions;
-using Xunit;
+using NUnit.Framework;
 
 namespace ReactiveUI.Uno.Tests.Platform;
 
+/// <summary>
+/// Tests for PlatformOperations.
+/// </summary>
+[TestFixture]
 public class PlatformOperationsTests
 {
-    [Fact]
+    /// <summary>
+    /// Ensures GetOrientation returns either null or a string value without throwing.
+    /// </summary>
+    [Test]
     public void GetOrientation_has_valid_string_or_null()
     {
         var ops = new ReactiveUI.Uno.PlatformOperations();

src/ReactiveUI.Uno.Tests/Properties/DependencyObjectObservableForPropertyTests.cs

@@ -0,0 +1,76 @@
+// Copyright (c) 2025 ReactiveUI and Contributors. All rights reserved.
+// Licensed to reactiveui and contributors under one or more agreements.
+// The reactiveui and contributors licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for full license information.
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using FluentAssertions;
+using NUnit.Framework;
+using ReactiveUI;
+using ReactiveUI.Uno;
+
+namespace ReactiveUI.Uno.Tests;
+
+/// <summary>
+/// RegistrationsTests.
+/// </summary>
+[TestFixture]
+public class RegistrationsTests
+{
+    /// <summary>
+    /// Resets the schedulers.
+    /// </summary>
+    [SetUp]
+    public void ResetSchedulers()
+    {
+        // Reset to defaults before each test to avoid cross-test pollution.
+        RxApp.MainThreadScheduler = null!;
+        RxApp.TaskpoolScheduler = null!;
+    }
+
+    /// <summary>
+    /// Registers the registers expected services and configures schedulers.
+    /// </summary>
+    [Test]
+    public void Register_RegistersExpectedServices_And_ConfiguresSchedulers()
+    {
+        var registered = new List<Type>();
+
+        void Register(Func<object> factory, Type serviceType)
+        {
+            // Don't invoke the factory here to avoid loading UI types in headless tests.
+            registered.Add(serviceType);
+        }
+
+        var sut = new Registrations();
+        sut.Invoking(x => x.Register(Register)).Should().NotThrow();
+
+        // Verify the set of required service interfaces are registered
+        registered.Should().Contain(typeof(IPlatformOperations));
+        registered.Should().Contain(typeof(IActivationForViewFetcher));
+        registered.Should().Contain(typeof(ICreatesObservableForProperty));
+        registered.Should().Contain(typeof(IPropertyBindingHook));
+        registered.Should().Contain(typeof(ISuspensionDriver));
+
+        // The implementation registers 16 binding converters + 2 hooks/services + 3 core services = 21 total
+        // (String/byte(short/int/long/float/double/decimal) + nullable versions + BooleanToVisibility)
+        registered.Count.Should().Be(21);
+
+        // Verify schedulers are set to safe defaults for headless environment
+        RxApp.TaskpoolScheduler.Should().BeSameAs(System.Reactive.Concurrency.TaskPoolScheduler.Default);
+        RxApp.MainThreadScheduler.Should().BeSameAs(System.Reactive.Concurrency.CurrentThreadScheduler.Instance);
+    }
+
+    /// <summary>
+    /// Registers the throws on null register function.
+    /// </summary>
+    [Test]
+    public void Register_Throws_On_Null_RegisterFunction()
+    {
+        var sut = new Registrations();
+        Action act = () => sut.Register(null!);
+        act.Should().Throw<ArgumentNullException>();
+    }
+}