test:WIP add tests. Change decade context end date.

tests/Test.Ursa/DateTimePickerTests/CalendarContextTests.cs

@@ -0,0 +1,122 @@
+using Ursa.Controls;
+
+namespace Test.Ursa.DateTimePicker;
+
+public class CalendarContextTests
+{
+    [Fact]
+    public void Clone_ReturnsExactCopy()
+    {
+        var context = new CalendarContext(2023, 5, 2000, 2030);
+        var clone = context.Clone();
+        Assert.Equal(context.Year, clone.Year);
+        Assert.Equal(context.Month, clone.Month);
+        Assert.Equal(context.StartYear, clone.StartYear);
+        Assert.Equal(context.EndYear, clone.EndYear);
+    }
+
+    [Fact]
+    public void Today_ReturnsCurrentDate()
+    {
+        var today = CalendarContext.Today();
+        Assert.Equal(DateTime.Today.Year, today.Year);
+        Assert.Equal(DateTime.Today.Month, today.Month);
+    }
+
+    [Fact]
+    public void With_UpdatesSpecifiedFields()
+    {
+        var context = new CalendarContext(2023, 5, 2000, 2030);
+        var updated = context.With(month: 6);
+        Assert.Equal(2023, updated.Year);
+        Assert.Equal(6, updated.Month);
+        Assert.Equal(2000, updated.StartYear);
+        Assert.Equal(2030, updated.EndYear);
+    }
+
+    [Fact]
+    public void NextMonth_UpdatesToNextMonth()
+    {
+        var context = new CalendarContext(2023, 5);
+        var nextMonth = context.NextMonth();
+        Assert.Equal(2023, nextMonth.Year);
+        Assert.Equal(6, nextMonth.Month);
+    }
+
+    [Fact]
+    public void NextMonth_UpdatesToNextYear()
+    {
+        var context = new CalendarContext(2023, 12);
+        var nextMonth = context.NextMonth();
+        Assert.Equal(2024, nextMonth.Year);
+        Assert.Equal(1, nextMonth.Month);
+    }
+
+    [Fact]
+    public void PreviousMonth_UpdatesToPreviousMonth()
+    {
+        var context = new CalendarContext(2023, 5);
+        var previousMonth = context.PreviousMonth();
+        Assert.Equal(2023, previousMonth.Year);
+        Assert.Equal(4, previousMonth.Month);
+    }
+
+    [Fact]
+    public void PreviousMonth_UpdatesToPreviousYear()
+    {
+        var context = new CalendarContext(2023, 1);
+        var previousMonth = context.PreviousMonth();
+        Assert.Equal(2022, previousMonth.Year);
+        Assert.Equal(12, previousMonth.Month);
+    }
+
+    [Fact]
+    public void NextYear_UpdatesToNextYear()
+    {
+        var context = new CalendarContext(2023, 5);
+        var nextYear = context.NextYear();
+        Assert.Equal(2024, nextYear.Year);
+        Assert.Equal(5, nextYear.Month);
+    }
+
+    [Fact]
+    public void PreviousYear_UpdatesToPreviousYear()
+    {
+        var context = new CalendarContext(2023, 5);
+        var previousYear = context.PreviousYear();
+        Assert.Equal(2022, previousYear.Year);
+        Assert.Equal(5, previousYear.Month);
+    }
+
+    [Fact]
+    public void CompareTo_SameContext_ReturnsZero()
+    {
+        var context1 = new CalendarContext(2023, 5);
+        var context2 = new CalendarContext(2023, 5);
+        Assert.Equal(0, context1.CompareTo(context2));
+    }
+
+    [Fact]
+    public void CompareTo_DifferentYear_ReturnsNonZero()
+    {
+        var context1 = new CalendarContext(2023, 5);
+        var context2 = new CalendarContext(2024, 5);
+        Assert.NotEqual(0, context1.CompareTo(context2));
+    }
+
+    [Fact]
+    public void CompareTo_DifferentMonth_ReturnsNonZero()
+    {
+        var context1 = new CalendarContext(2023, 5);
+        var context2 = new CalendarContext(2023, 6);
+        Assert.NotEqual(0, context1.CompareTo(context2));
+    }
+
+    [Fact]
+    public void ToString_ReturnsCorrectFormat()
+    {
+        var context = new CalendarContext(2023, 5, 2000, 2030);
+        var expected = "Start: 2000, End: 2030, Year: 2023, Month: 5";
+        Assert.Equal(expected, context.ToString());
+    }
+}

tests/Test.Ursa/DateTimePickerTests/CalendarDayButtonTests.cs

@@ -0,0 +1,91 @@
+using Avalonia.Input;
+using Irihi.Avalonia.Shared.Common;
+using CalendarDayButton = Ursa.Controls.CalendarDayButton;
+
+namespace Test.Ursa.DateTimePicker;
+
+public class CalendarDayButtonTests
+{
+    [Fact]
+    public void IsToday_SetsPseudoClass()
+    {
+        var button = new CalendarDayButton();
+        button.IsToday = true;
+        Assert.Contains(CalendarDayButton.PC_Today, button.Classes);
+    }
+
+    [Fact]
+    public void IsStartDate_SetsPseudoClass()
+    {
+        var button = new CalendarDayButton();
+        button.IsStartDate = true;
+        Assert.Contains(CalendarDayButton.PC_StartDate, button.Classes);
+    }
+
+    [Fact]
+    public void IsEndDate_SetsPseudoClass()
+    {
+        var button = new CalendarDayButton();
+        button.IsEndDate = true;
+        Assert.Contains(CalendarDayButton.PC_EndDate, button.Classes);
+    }
+
+    [Fact]
+    public void IsPreviewStartDate_SetsPseudoClass()
+    {
+        var button = new CalendarDayButton();
+        button.IsPreviewStartDate = true;
+        Assert.Contains(CalendarDayButton.PC_PreviewStartDate, button.Classes);
+    }
+
+    [Fact]
+    public void IsPreviewEndDate_SetsPseudoClass()
+    {
+        var button = new CalendarDayButton();
+        button.IsPreviewEndDate = true;
+        Assert.Contains(CalendarDayButton.PC_PreviewEndDate, button.Classes);
+    }
+
+    [Fact]
+    public void IsInRange_SetsPseudoClass()
+    {
+        var button = new CalendarDayButton();
+        button.IsInRange = true;
+        Assert.Contains(CalendarDayButton.PC_InRange, button.Classes);
+    }
+
+    [Fact]
+    public void IsSelected_SetsPseudoClass()
+    {
+        var button = new CalendarDayButton();
+        button.IsSelected = true;
+        Assert.Contains(PseudoClassName.PC_Selected, button.Classes);
+    }
+
+    [Fact]
+    public void IsBlackout_SetsPseudoClass()
+    {
+        var button = new CalendarDayButton();
+        button.IsBlackout = true;
+        Assert.Contains(CalendarDayButton.PC_Blackout, button.Classes);
+    }
+
+    [Fact]
+    public void IsNotCurrentMonth_SetsPseudoClass()
+    {
+        var button = new CalendarDayButton();
+        button.IsNotCurrentMonth = true;
+        Assert.Contains(CalendarDayButton.PC_NotCurrentMonth, button.Classes);
+    }
+
+    [Fact]
+    public void ResetSelection_ClearsPseudoClasses()
+    {
+        var button = new CalendarDayButton();
+        button.IsSelected = true;
+        button.IsStartDate = true;
+        button.ResetSelection();
+        Assert.DoesNotContain(PseudoClassName.PC_Selected, button.Classes);
+        Assert.DoesNotContain(CalendarDayButton.PC_StartDate, button.Classes);
+    }
+}

tests/Test.Ursa/DateTimePickerTests/DateTimeHelperTests.cs

@@ -0,0 +1,74 @@
+using Ursa.Controls;
+
+namespace Test.Ursa.DateTimePicker;
+
+public class DateTimeHelperTests
+{
+    [Fact]
+    public void GetFirstDayOfMonth_ReturnsFirstDay()
+    {
+        var date = new DateTime(2023, 5, 15);
+        var firstDay = date.GetFirstDayOfMonth();
+        Assert.Equal(new DateTime(2023, 5, 1), firstDay);
+    }
+
+    [Fact]
+    public void GetLastDayOfMonth_ReturnsLastDay()
+    {
+        var date = new DateTime(2023, 5, 15);
+        var lastDay = date.GetLastDayOfMonth();
+        Assert.Equal(new DateTime(2023, 5, 31), lastDay);
+    }
+
+    [Fact]
+    public void CompareYearMonth_SameYearMonth_ReturnsZero()
+    {
+        var date1 = new DateTime(2023, 5, 15);
+        var date2 = new DateTime(2023, 5, 20);
+        var result = DateTimeHelper.CompareYearMonth(date1, date2);
+        Assert.Equal(0, result);
+    }
+
+    [Fact]
+    public void CompareYearMonth_DifferentYearMonth_ReturnsDifference()
+    {
+        var date1 = new DateTime(2023, 5, 15);
+        var date2 = new DateTime(2024, 6, 20);
+        var result = DateTimeHelper.CompareYearMonth(date1, date2);
+        Assert.Equal(-13, result);
+    }
+
+    [Fact]
+    public void Min_ReturnsMinimumDate()
+    {
+        var date1 = new DateTime(2023, 5, 15);
+        var date2 = new DateTime(2024, 6, 20);
+        var result = DateTimeHelper.Min(date1, date2);
+        Assert.Equal(date1, result);
+    }
+
+    [Fact]
+    public void Max_ReturnsMaximumDate()
+    {
+        var date1 = new DateTime(2023, 5, 15);
+        var date2 = new DateTime(2024, 6, 20);
+        var result = DateTimeHelper.Max(date1, date2);
+        Assert.Equal(date2, result);
+    }
+
+    [Fact]
+    public void GetDecadeViewRangeByYear_ReturnsCorrectRange()
+    {
+        var year = 2023;
+        var result = DateTimeHelper.GetDecadeViewRangeByYear(year);
+        Assert.Equal((2020, 2029), result);
+    }
+
+    [Fact]
+    public void GetCenturyViewRangeByYear_ReturnsCorrectRange()
+    {
+        var year = 2023;
+        var result = DateTimeHelper.GetCenturyViewRangeByYear(year);
+        Assert.Equal((2000, 2100), result);
+    }
+}