Performance improvements

Maui.DataGrid.Sample/Tests/BindablePropertyExtensionsTest.cs

@@ -0,0 +1,47 @@
+namespace Maui.DataGrid.Sample.Tests;
+
+using Maui.DataGrid.Extensions;
+using Xunit;
+
+public class BindablePropertyExtensionsTest
+{
+    private static readonly BindableProperty TestProperty =
+        BindablePropertyExtensions.Create<TestBindable, string>("default");
+
+    private static readonly BindableProperty NumericProperty =
+        BindablePropertyExtensions.Create<TestBindable, int>(42);
+
+    [Fact]
+    public void Create_SetsDefaultValue()
+    {
+        var bindable = new TestBindable();
+
+        Assert.Equal("default", bindable.GetValue(TestProperty));
+    }
+
+    [Fact]
+    public void Create_TrimsPropertySuffix()
+    {
+        Assert.Equal("Test", TestProperty.PropertyName);
+    }
+
+    [Fact]
+    public void Create_NumericDefaultValue()
+    {
+        var bindable = new TestBindable();
+
+        Assert.Equal(42, bindable.GetValue(NumericProperty));
+    }
+
+    [Fact]
+    public void Create_SetAndGetValue()
+    {
+        var bindable = new TestBindable();
+
+        bindable.SetValue(TestProperty, "updated");
+
+        Assert.Equal("updated", bindable.GetValue(TestProperty));
+    }
+
+    private class TestBindable : BindableObject;
+}

Maui.DataGrid.Sample/Tests/ConvertersTest.cs

@@ -0,0 +1,162 @@
+namespace Maui.DataGrid.Sample.Tests;
+
+using System.Globalization;
+using Maui.DataGrid.Converters;
+using Xunit;
+
+public class ConvertersTest
+{
+    private readonly BorderThicknessToCellPaddingConverter _borderConverter = new();
+    private readonly SortDataTypeConverter _sortDataConverter = new();
+
+    [Fact]
+    public void BorderConverter_ThicknessIsDividedByTwo()
+    {
+        var thickness = new Thickness(4, 6, 8, 10);
+
+        var result = (Thickness)_borderConverter.Convert(thickness, null, null, null);
+
+        Assert.Equal(new Thickness(2, 3, 4, 5), result);
+    }
+
+    [Fact]
+    public void BorderConverter_UniformThickness()
+    {
+        var thickness = new Thickness(2);
+
+        var result = (Thickness)_borderConverter.Convert(thickness, null, null, null);
+
+        Assert.Equal(new Thickness(1), result);
+    }
+
+    [Fact]
+    public void BorderConverter_ZeroThickness()
+    {
+        var thickness = new Thickness(0);
+
+        var result = (Thickness)_borderConverter.Convert(thickness, null, null, null);
+
+        Assert.Equal(new Thickness(0), result);
+    }
+
+    [Fact]
+    public void BorderConverter_NonThicknessReturnsZero()
+    {
+        var result = (Thickness)_borderConverter.Convert("invalid", null, null, null);
+
+        Assert.Equal(new Thickness(0), result);
+    }
+
+    [Fact]
+    public void BorderConverter_NullReturnsZero()
+    {
+        var result = (Thickness)_borderConverter.Convert(null, null, null, null);
+
+        Assert.Equal(new Thickness(0), result);
+    }
+
+    [Fact]
+    public void BorderConverter_ConvertBackThrows()
+    {
+        Assert.Throws<NotImplementedException>(() =>
+            _borderConverter.ConvertBack(null, null, null, null));
+    }
+
+    [Fact]
+    public void SortDataConverter_NullReturnsNull()
+    {
+        var result = _sortDataConverter.ConvertFrom(null, null, null!);
+
+        Assert.Null(result);
+    }
+
+    [Fact]
+    public void SortDataConverter_PositiveIntReturnsAscendant()
+    {
+        var result = (SortData)_sortDataConverter.ConvertFrom(null, null, 3)!;
+
+        Assert.Equal(3, result.Index);
+        Assert.Equal(SortingOrder.Ascendant, result.Order);
+    }
+
+    [Fact]
+    public void SortDataConverter_NegativeIntReturnsDescendant()
+    {
+        var result = (SortData)_sortDataConverter.ConvertFrom(null, null, -2)!;
+
+        Assert.Equal(2, result.Index);
+        Assert.Equal(SortingOrder.Descendant, result.Order);
+    }
+
+    [Fact]
+    public void SortDataConverter_StringParsesToSortData()
+    {
+        var result = (SortData)_sortDataConverter.ConvertFrom(null, CultureInfo.InvariantCulture, "4")!;
+
+        Assert.Equal(4, result.Index);
+        Assert.Equal(SortingOrder.Ascendant, result.Order);
+    }
+
+    [Fact]
+    public void SortDataConverter_NegativeStringParsesToDescendant()
+    {
+        var result = (SortData)_sortDataConverter.ConvertFrom(null, CultureInfo.InvariantCulture, "-1")!;
+
+        Assert.Equal(1, result.Index);
+        Assert.Equal(SortingOrder.Descendant, result.Order);
+    }
+
+    [Fact]
+    public void SortDataConverter_ZeroIntReturnsAscendant()
+    {
+        var result = (SortData)_sortDataConverter.ConvertFrom(null, null, 0)!;
+
+        Assert.Equal(0, result.Index);
+        Assert.Equal(SortingOrder.Ascendant, result.Order);
+    }
+
+    [Fact]
+    public void SortDataConverter_DescStringFormatParsesToDescendant()
+    {
+        var result = (SortData)_sortDataConverter.ConvertFrom(null, CultureInfo.InvariantCulture, "3 DESC")!;
+
+        Assert.Equal(3, result.Index);
+        Assert.Equal(SortingOrder.Descendant, result.Order);
+    }
+
+    [Fact]
+    public void SortDataConverter_AscStringFormatParsesToAscendant()
+    {
+        var result = (SortData)_sortDataConverter.ConvertFrom(null, CultureInfo.InvariantCulture, "2 ASC")!;
+
+        Assert.Equal(2, result.Index);
+        Assert.Equal(SortingOrder.Ascendant, result.Order);
+    }
+
+    [Fact]
+    public void SortDataConverter_ZeroDescStringFormatParsesToDescendant()
+    {
+        var result = (SortData)_sortDataConverter.ConvertFrom(null, CultureInfo.InvariantCulture, "0 DESC")!;
+
+        Assert.Equal(0, result.Index);
+        Assert.Equal(SortingOrder.Descendant, result.Order);
+    }
+
+    [Fact]
+    public void SortDataConverter_DescCaseInsensitive()
+    {
+        var result = (SortData)_sortDataConverter.ConvertFrom(null, CultureInfo.InvariantCulture, "1 desc")!;
+
+        Assert.Equal(1, result.Index);
+        Assert.Equal(SortingOrder.Descendant, result.Order);
+    }
+
+    [Fact]
+    public void SortDataConverter_ZeroStringParsesToAscendant()
+    {
+        var result = (SortData)_sortDataConverter.ConvertFrom(null, CultureInfo.InvariantCulture, "0")!;
+
+        Assert.Equal(0, result.Index);
+        Assert.Equal(SortingOrder.Ascendant, result.Order);
+    }
+}

Maui.DataGrid.Sample/Tests/DataGridColumnTest.cs

@@ -0,0 +1,99 @@
+namespace Maui.DataGrid.Sample.Tests;
+
+using Maui.DataGrid.Sample.Tests.TestUtils;
+using Xunit;
+
+public class DataGridColumnTest
+{
+    [Fact]
+    public void DefaultPropertyValues()
+    {
+        var column = new DataGridColumn();
+
+        Assert.Equal(string.Empty, column.Title);
+        Assert.Equal(GridLength.Star, column.Width);
+        Assert.True(column.IsVisible);
+        Assert.True(column.SortingEnabled);
+        Assert.True(column.FilteringEnabled);
+        Assert.Equal(LineBreakMode.WordWrap, column.LineBreakMode);
+        Assert.Equal(LayoutOptions.Center, column.HorizontalContentAlignment);
+        Assert.Equal(LayoutOptions.Center, column.VerticalContentAlignment);
+        Assert.Null(column.PropertyName);
+        Assert.Null(column.StringFormat);
+        Assert.Null(column.CellTemplate);
+    }
+
+    [Fact]
+    public void IsSortableReturnsTrueForComparableType()
+    {
+        var column = new DataGridColumn { PropertyName = "Value" };
+
+        var teams = new List<TestItem> { new() { Value = 1 } };
+        var dataGrid = new DataGrid
+        {
+            ItemsSource = teams,
+            Columns = [column]
+        };
+
+        column.DataGrid = dataGrid;
+        column.InitializeDataType();
+
+        Assert.True(column.IsSortable());
+    }
+
+    [Fact]
+    public void IsSortableReturnsFalseForNonComparableType()
+    {
+        var column = new DataGridColumn { PropertyName = "NonComparable" };
+
+        var items = new List<TestItemWithNonComparable> { new() { NonComparable = new object() } };
+        var dataGrid = new DataGrid
+        {
+            ItemsSource = items,
+            Columns = [column]
+        };
+
+        column.DataGrid = dataGrid;
+        column.InitializeDataType();
+
+        Assert.False(column.IsSortable());
+    }
+
+    [Fact]
+    public void TitlePropertyBinding()
+    {
+        var column = new DataGridColumn();
+        column.CheckPropertyBindingWorks(DataGridColumn.TitleProperty, "Column A", "Column B");
+    }
+
+    [Fact]
+    public void WidthPropertyBinding()
+    {
+        var column = new DataGridColumn();
+        column.CheckPropertyBindingWorks(DataGridColumn.WidthProperty, new GridLength(100), new GridLength(200));
+    }
+
+    [Fact]
+    public void IsVisiblePropertyBinding()
+    {
+        var column = new DataGridColumn();
+        column.CheckPropertyBindingWorks(DataGridColumn.IsVisibleProperty, false, true);
+    }
+
+    [Fact]
+    public void SortingEnabledPropertyBinding()
+    {
+        var column = new DataGridColumn();
+        column.CheckPropertyBindingWorks(DataGridColumn.SortingEnabledProperty, false, true);
+    }
+
+    public class TestItem
+    {
+        public int Value { get; set; }
+    }
+
+    public class TestItemWithNonComparable
+    {
+        public object? NonComparable { get; set; }
+    }
+}

Maui.DataGrid.Sample/Tests/LayoutOptionsExtensionsTest.cs

@@ -0,0 +1,39 @@
+namespace Maui.DataGrid.Sample.Tests;
+
+using Maui.DataGrid.Extensions;
+using Xunit;
+
+public class LayoutOptionsExtensionsTest
+{
+    [Fact]
+    public void StartLayoutReturnsStartTextAlignment()
+    {
+        var result = LayoutOptions.Start.ToTextAlignment();
+
+        Assert.Equal(TextAlignment.Start, result);
+    }
+
+    [Fact]
+    public void EndLayoutReturnsEndTextAlignment()
+    {
+        var result = LayoutOptions.End.ToTextAlignment();
+
+        Assert.Equal(TextAlignment.End, result);
+    }
+
+    [Fact]
+    public void CenterLayoutReturnsCenterTextAlignment()
+    {
+        var result = LayoutOptions.Center.ToTextAlignment();
+
+        Assert.Equal(TextAlignment.Center, result);
+    }
+
+    [Fact]
+    public void FillLayoutReturnsCenterTextAlignment()
+    {
+        var result = LayoutOptions.Fill.ToTextAlignment();
+
+        Assert.Equal(TextAlignment.Center, result);
+    }
+}