Add comprehensive test coverage for many controls (#737)

Co-authored-by: rabbitism <14807942+rabbitism@users.noreply.github.com>
Co-authored-by: Copilot <198982749+Copilot@users.noreply.github.com>

tests/Test.Ursa/AnchorTests/AnchorUnitTests.cs

@@ -0,0 +1,121 @@
+using Avalonia;
+using Avalonia.Controls;
+using Avalonia.Controls.Primitives;
+using Ursa.Controls;
+
+namespace Test.Ursa.AnchorTests;
+
+public class AnchorUnitTests
+{
+    [Fact]
+    public void Anchor_Properties_Should_Have_Correct_Default_Values()
+    {
+        var anchor = new Anchor();
+        
+        Assert.Null(anchor.TargetContainer);
+        Assert.Equal(0.0, anchor.TopOffset);
+    }
+
+    [Fact]
+    public void Anchor_Should_Set_And_Get_TargetContainer()
+    {
+        var anchor = new Anchor();
+        var scrollViewer = new ScrollViewer();
+        
+        anchor.TargetContainer = scrollViewer;
+        Assert.Equal(scrollViewer, anchor.TargetContainer);
+        
+        anchor.TargetContainer = null;
+        Assert.Null(anchor.TargetContainer);
+    }
+
+    [Fact]
+    public void Anchor_Should_Set_And_Get_TopOffset()
+    {
+        var anchor = new Anchor();
+        
+        anchor.TopOffset = 25.5;
+        Assert.Equal(25.5, anchor.TopOffset);
+        
+        anchor.TopOffset = -10.0;
+        Assert.Equal(-10.0, anchor.TopOffset);
+        
+        anchor.TopOffset = 0.0;
+        Assert.Equal(0.0, anchor.TopOffset);
+    }
+
+    [Fact]
+    public void Anchor_Id_AttachedProperty_Should_Work_With_Different_Visual_Types()
+    {
+        var border = new Border();
+        var textBlock = new TextBlock();
+        var stackPanel = new StackPanel();
+        
+        // Test with Border
+        Anchor.SetId(border, "border-id");
+        Assert.Equal("border-id", Anchor.GetId(border));
+        
+        // Test with TextBlock
+        Anchor.SetId(textBlock, "text-id");
+        Assert.Equal("text-id", Anchor.GetId(textBlock));
+        
+        // Test with StackPanel
+        Anchor.SetId(stackPanel, "panel-id");
+        Assert.Equal("panel-id", Anchor.GetId(stackPanel));
+        
+        // Test setting to null
+        Anchor.SetId(border, null);
+        Assert.Null(Anchor.GetId(border));
+    }
+
+    [Fact]
+    public void AnchorItem_Properties_Should_Have_Correct_Default_Values()
+    {
+        var anchorItem = new AnchorItem();
+        
+        Assert.Null(anchorItem.AnchorId);
+        Assert.False(anchorItem.IsSelected);
+        Assert.Equal(0, anchorItem.Level); // Default level before attachment
+    }
+
+    [Fact]
+    public void AnchorItem_Should_Set_And_Get_AnchorId()
+    {
+        var anchorItem = new AnchorItem();
+        
+        anchorItem.AnchorId = "test-anchor";
+        Assert.Equal("test-anchor", anchorItem.AnchorId);
+        
+        anchorItem.AnchorId = null;
+        Assert.Null(anchorItem.AnchorId);
+        
+        anchorItem.AnchorId = "";
+        Assert.Equal("", anchorItem.AnchorId);
+    }
+
+    [Fact]
+    public void AnchorItem_Should_Set_And_Get_IsSelected()
+    {
+        var anchorItem = new AnchorItem();
+        
+        anchorItem.IsSelected = true;
+        Assert.True(anchorItem.IsSelected);
+        
+        anchorItem.IsSelected = false;
+        Assert.False(anchorItem.IsSelected);
+    }
+
+    [Fact]
+    public void Anchor_Should_Create_AnchorItem_Containers()
+    {
+        var anchor = new Anchor();
+        
+        // Test NeedsContainer
+        var needsContainer = anchor.NeedsContainerOverrideInternal("test-item", 0, out var recycleKey);
+        Assert.True(needsContainer);
+        
+        // Test CreateContainer
+        var container = anchor.CreateContainerForItemOverrideInternal("test-item", 0, recycleKey);
+        Assert.IsType<AnchorItem>(container);
+    }
+}

tests/Test.Ursa/ButtonGroupTests/ButtonGroupTests.cs

@@ -0,0 +1,67 @@
+using Avalonia.Data;
+using Ursa.Controls;
+
+namespace Test.Ursa.ButtonGroupTests;
+
+public class ButtonGroupTests
+{
+    [Fact]
+    public void ButtonGroup_Should_Initialize_With_Default_Values()
+    {
+        var buttonGroup = new ButtonGroup();
+        
+        Assert.Null(buttonGroup.CommandBinding);
+        Assert.Null(buttonGroup.CommandParameterBinding);
+        Assert.Null(buttonGroup.ContentBinding);
+        Assert.NotNull(buttonGroup.Items);
+        Assert.Empty(buttonGroup.Items);
+    }
+
+    [Fact]
+    public void ButtonGroup_Should_Set_And_Get_CommandBinding()
+    {
+        var buttonGroup = new ButtonGroup();
+        var binding = new Binding("TestCommand");
+        
+        buttonGroup.CommandBinding = binding;
+        
+        Assert.Equal(binding, buttonGroup.CommandBinding);
+    }
+
+    [Fact]
+    public void ButtonGroup_Should_Set_And_Get_CommandParameterBinding()
+    {
+        var buttonGroup = new ButtonGroup();
+        var binding = new Binding("TestParameter");
+        
+        buttonGroup.CommandParameterBinding = binding;
+        
+        Assert.Equal(binding, buttonGroup.CommandParameterBinding);
+    }
+
+    [Fact]
+    public void ButtonGroup_Should_Set_And_Get_ContentBinding()
+    {
+        var buttonGroup = new ButtonGroup();
+        var binding = new Binding("TestContent");
+        
+        buttonGroup.ContentBinding = binding;
+        
+        Assert.Equal(binding, buttonGroup.ContentBinding);
+    }
+
+    [Fact]
+    public void ButtonGroup_Should_Accept_Items_In_Collection()
+    {
+        var buttonGroup = new ButtonGroup();
+        var item1 = "Item 1";
+        var item2 = new Avalonia.Controls.Button { Content = "Button Item" };
+        
+        buttonGroup.Items.Add(item1);
+        buttonGroup.Items.Add(item2);
+        
+        Assert.Equal(2, buttonGroup.Items.Count);
+        Assert.Contains(item1, buttonGroup.Items);
+        Assert.Contains(item2, buttonGroup.Items);
+    }
+}

tests/Test.Ursa/OverlayFeedbackElementTests/OverlayFeedbackElementUnitTests.cs

@@ -0,0 +1,185 @@
+using Irihi.Avalonia.Shared.Contracts;
+using Ursa.Controls.OverlayShared;
+
+namespace Test.Ursa.OverlayFeedbackElementTests;
+
+/// <summary>
+/// Simple unit tests for OverlayFeedbackElement that don't require UI framework
+/// </summary>
+public class OverlayFeedbackElementUnitTests
+{
+    /// <summary>
+    /// Minimal test implementation of OverlayFeedbackElement
+    /// </summary>
+    private class TestOverlayFeedbackElement : OverlayFeedbackElement
+    {
+        public bool CloseWasCalled { get; private set; }
+        public bool AnchorWasCalled { get; private set; }
+
+        public override void Close()
+        {
+            CloseWasCalled = true;
+            OnElementClosing(this, "test_result");
+        }
+
+        protected internal override void AnchorAndUpdatePositionInfo()
+        {
+            AnchorWasCalled = true;
+        }
+
+        // Expose protected method for testing
+        public void TestOnElementClosing(object? sender, object? args)
+        {
+            OnElementClosing(sender, args);
+        }
+    }
+
+    private class MockDialogContext : IDialogContext
+    {
+        public event EventHandler<object?>? RequestClose;
+
+        public void Close()
+        {
+            RequestClose?.Invoke(this, null);
+        }
+
+        public void TriggerRequestClose(object? result = null)
+        {
+            RequestClose?.Invoke(this, result);
+        }
+    }
+
+    [Fact]
+    public void IsClosed_Should_Default_To_True()
+    {
+        var element = new TestOverlayFeedbackElement();
+        Assert.True(element.IsClosed);
+    }
+
+    [Fact]
+    public void IsClosed_Can_Be_Set_And_Retrieved()
+    {
+        var element = new TestOverlayFeedbackElement();
+        
+        element.IsClosed = false;
+        Assert.False(element.IsClosed);
+        
+        element.IsClosed = true;
+        Assert.True(element.IsClosed);
+    }
+
+    [Fact]
+    public void Close_Method_Should_Be_Called()
+    {
+        var element = new TestOverlayFeedbackElement();
+        
+        element.Close();
+        
+        Assert.True(element.CloseWasCalled);
+    }
+
+    [Fact]
+    public void OnElementClosing_Should_Raise_Closed_Event()
+    {
+        var element = new TestOverlayFeedbackElement();
+        var eventRaised = false;
+        object? eventResult = null;
+        
+        element.Closed += (sender, args) =>
+        {
+            eventRaised = true;
+            eventResult = args.Result;
+        };
+        
+        element.TestOnElementClosing(element, "test_result");
+        
+        Assert.True(eventRaised);
+        Assert.Equal("test_result", eventResult);
+    }
+
+    [Fact]
+    public void Closed_Event_Should_Set_IsClosed_To_True()
+    {
+        var element = new TestOverlayFeedbackElement();
+        element.IsClosed = false;
+        
+        element.TestOnElementClosing(element, "test_result");
+        
+        Assert.True(element.IsClosed);
+    }
+
+    [Fact]
+    public void DataContext_With_IDialogContext_Should_Subscribe_To_RequestClose()
+    {
+        var element = new TestOverlayFeedbackElement();
+        var mockContext = new MockDialogContext();
+        var eventRaised = false;
+        
+        element.Closed += (sender, args) =>
+        {
+            eventRaised = true;
+        };
+        
+        element.DataContext = mockContext;
+        mockContext.TriggerRequestClose("context_result");
+        
+        Assert.True(eventRaised);
+    }
+
+    [Fact]
+    public void DataContext_Change_Should_Unsubscribe_From_Previous_Context()
+    {
+        var element = new TestOverlayFeedbackElement();
+        var oldContext = new MockDialogContext();
+        var newContext = new MockDialogContext();
+        var eventRaisedCount = 0;
+        
+        element.Closed += (sender, args) =>
+        {
+            eventRaisedCount++;
+        };
+        
+        // Set first context
+        element.DataContext = oldContext;
+        
+        // Change to new context
+        element.DataContext = newContext;
+        
+        // Trigger on old context - should NOT raise event
+        oldContext.TriggerRequestClose("old_result");
+        Assert.Equal(0, eventRaisedCount);
+        
+        // Trigger on new context - should raise event
+        newContext.TriggerRequestClose("new_result");
+        Assert.Equal(1, eventRaisedCount);
+    }
+
+    [Fact]
+    public void IsShowAsync_Property_Should_Be_Set_During_ShowAsync()
+    {
+        var element = new TestOverlayFeedbackElement();
+        
+        Assert.False(element.IsShowAsync);
+        
+        var task = element.ShowAsync<string>();
+        Assert.True(element.IsShowAsync);
+        
+        // Complete the async operation
+        element.TestOnElementClosing(element, "result");
+        
+        // Should be reset after completion
+        Assert.False(element.IsShowAsync);
+    }
+
+    [Fact]
+    public void AnchorAndUpdatePositionInfo_Should_Be_Callable()
+    {
+        var element = new TestOverlayFeedbackElement();
+        
+        Assert.False(element.AnchorWasCalled);
+        
+        element.AnchorAndUpdatePositionInfo();
+        
+        Assert.True(element.AnchorWasCalled);
+    }
+}