Migrate 210 tests to UnitTests.Parallelizable, add CreateFakeDriver helper, prove View.Draw() works in parallel tests, and provide comprehensive performance analysis (#4297)

* Initial plan * Migrate Category A test files to UnitTests.Parallelizable (135 tests) Co-authored-by: tig <585482+tig@users.noreply.github.com> * Add 11 ButtonTests to Parallelizable, remove from UnitTests Co-authored-by: tig <585482+tig@users.noreply.github.com> * Add comprehensive test migration report Co-authored-by: tig <585482+tig@users.noreply.github.com> * Add comprehensive performance analysis of UnitTests Co-authored-by: tig <585482+tig@users.noreply.github.com> * Migrate 2 Autocomplete tests and add Text tests analysis Co-authored-by: tig <585482+tig@users.noreply.github.com> * Add proof-of-concept: TextFormatter.Draw works in parallel tests with local driver Co-authored-by: tig <585482+tig@users.noreply.github.com> * Add CreateFakeDriver helper to ParallelizableBase and migrate 4 TextFormatterTests Co-authored-by: tig <585482+tig@users.noreply.github.com> * Remove proof-of-concept test from AutocompleteTests Co-authored-by: tig <585482+tig@users.noreply.github.com> * Move Scheme-accessing tests back to UnitTests to fix intermittent failures Co-authored-by: tig <585482+tig@users.noreply.github.com> * Update parallel tests README to document ConfigurationManager/SchemeManager restrictions Co-authored-by: tig <585482+tig@users.noreply.github.com> * Document static member restriction in parallel tests README Co-authored-by: tig <585482+tig@users.noreply.github.com> * Restore accidentally deleted ButtonTests.Accept_Cancel_Event_OnAccept_Returns_True test Co-authored-by: tig <585482+tig@users.noreply.github.com> * Migrate Accept_Cancel_Event_OnAccept_Returns_True test to Parallelizable Co-authored-by: tig <585482+tig@users.noreply.github.com> --------- Co-authored-by: copilot-swe-agent[bot] <198982749+Copilot@users.noreply.github.com> Co-authored-by: tig <585482+tig@users.noreply.github.com>
2025-12-26 15:57:56 +01:00 · 2025-10-20 08:56:11 -06:00
parent ed64f5773e
commit 041e9de70e
25 changed files with 1561 additions and 348 deletions
--- a/Tests/UnitTestsParallelizable/Views/ButtonTests.cs
+++ b/Tests/UnitTestsParallelizable/Views/ButtonTests.cs
@@ -144,4 +144,182 @@ public class ButtonTests : UnitTests.Parallelizable.ParallelizableBase
        Assert.Equal (KeyCode.R, args.NewKey);
        btn.Dispose ();
    }
+
+    [Fact]
+    public void HotKeyChange_Works ()
+    {
+        var clicked = false;
+        var btn = new Button { Text = "_Test" };
+        btn.Accepting += (s, e) => clicked = true;
+
+        Assert.Equal (KeyCode.T, btn.HotKey);
+        Assert.False (btn.NewKeyDownEvent (Key.T)); // Button processes, but does not handle
+        Assert.True (clicked);
+
+        clicked = false;
+        Assert.False (btn.NewKeyDownEvent (Key.T.WithAlt)); // Button processes, but does not handle
+        Assert.True (clicked);
+
+        clicked = false;
+        btn.HotKey = KeyCode.E;
+        Assert.False (btn.NewKeyDownEvent (Key.E.WithAlt)); // Button processes, but does not handle
+        Assert.True (clicked);
+    }
+
+    [Theory]
+    [InlineData (false, 0)]
+    [InlineData (true, 1)]
+    public void Space_Fires_Accept (bool focused, int expected)
+    {
+        var superView = new View
+        {
+            CanFocus = true
+        };
+
+        Button button = new ();
+
+        button.CanFocus = focused;
+
+        var acceptInvoked = 0;
+        button.Accepting += (s, e) => acceptInvoked++;
+
+        superView.Add (button);
+        button.SetFocus ();
+        Assert.Equal (focused, button.HasFocus);
+
+        superView.NewKeyDownEvent (Key.Space);
+
+        Assert.Equal (expected, acceptInvoked);
+
+        superView.Dispose ();
+    }
+
+    [Theory]
+    [InlineData (false, 0)]
+    [InlineData (true, 1)]
+    public void Enter_Fires_Accept (bool focused, int expected)
+    {
+        var superView = new View
+        {
+            CanFocus = true
+        };
+
+        Button button = new ();
+
+        button.CanFocus = focused;
+
+        var acceptInvoked = 0;
+        button.Accepting += (s, e) => acceptInvoked++;
+
+        superView.Add (button);
+        button.SetFocus ();
+        Assert.Equal (focused, button.HasFocus);
+
+        superView.NewKeyDownEvent (Key.Enter);
+
+        Assert.Equal (expected, acceptInvoked);
+
+        superView.Dispose ();
+    }
+
+    [Theory]
+    [InlineData (false, 1)]
+    [InlineData (true, 1)]
+    public void HotKey_Fires_Accept (bool focused, int expected)
+    {
+        var superView = new View
+        {
+            CanFocus = true
+        };
+
+        Button button = new ()
+        {
+            HotKey = Key.A
+        };
+
+        button.CanFocus = focused;
+
+        var acceptInvoked = 0;
+        button.Accepting += (s, e) => acceptInvoked++;
+
+        superView.Add (button);
+        button.SetFocus ();
+        Assert.Equal (focused, button.HasFocus);
+
+        superView.NewKeyDownEvent (Key.A);
+
+        Assert.Equal (expected, acceptInvoked);
+
+        superView.Dispose ();
+    }
+
+    [Fact]
+    public void HotKey_Command_Accepts ()
+    {
+        var btn = new Button { Text = "_Test" };
+        var accepted = false;
+        btn.Accepting += (s, e) => accepted = true;
+
+        Assert.Equal (KeyCode.T, btn.HotKey);
+        btn.InvokeCommand (Command.HotKey);
+        Assert.True (accepted);
+    }
+
+    [Fact]
+    public void Accept_Event_Returns_True ()
+    {
+        var btn = new Button { Text = "Test" };
+        var acceptInvoked = false;
+        btn.Accepting += (s, e) => { acceptInvoked = true; e.Handled = true; };
+
+        Assert.True (btn.InvokeCommand (Command.Accept));
+        Assert.True (acceptInvoked);
+    }
+
+    [Fact]
+    public void Setting_Empty_Text_Sets_HoKey_To_KeyNull ()
+    {
+        var btn = new Button { Text = "_Test" };
+
+        Assert.Equal (KeyCode.T, btn.HotKey);
+
+        btn.Text = "";
+
+        Assert.Equal (KeyCode.Null, btn.HotKey);
+    }
+
+    [Fact]
+    public void TestAssignTextToButton ()
+    {
+        var btn = new Button { Text = "_K Ok" };
+
+        Assert.Equal ("_K Ok", btn.Text);
+
+        btn.Text = "_N Btn";
+
+        Assert.Equal ("_N Btn", btn.Text);
+    }
+
+    [Fact]
+    public void Accept_Cancel_Event_OnAccept_Returns_True ()
+    {
+        var button = new Button ();
+        var acceptInvoked = false;
+
+        button.Accepting += ButtonAccept;
+
+        bool? ret = button.InvokeCommand (Command.Accept);
+        Assert.True (ret);
+        Assert.True (acceptInvoked);
+
+        button.Dispose ();
+
+        return;
+
+        void ButtonAccept (object sender, CommandEventArgs e)
+        {
+            acceptInvoked = true;
+            e.Handled = true;
+        }
+    }
 }
--- a/Tests/UnitTestsParallelizable/Views/SliderTests.cs
+++ b/Tests/UnitTestsParallelizable/Views/SliderTests.cs
@@ -0,0 +1,597 @@
+using System.Text;
+
+namespace Terminal.Gui.ViewsTests;
+
+public class SliderOptionTests : UnitTests.Parallelizable.ParallelizableBase
+{
+    [Fact]
+    public void OnChanged_Should_Raise_ChangedEvent ()
+    {
+        // Arrange
+        SliderOption<int> sliderOption = new ();
+        var eventRaised = false;
+        sliderOption.Changed += (sender, args) => eventRaised = true;
+
+        // Act
+        sliderOption.OnChanged (true);
+
+        // Assert
+        Assert.True (eventRaised);
+    }
+
+    [Fact]
+    public void OnSet_Should_Raise_SetEvent ()
+    {
+        // Arrange
+        SliderOption<int> sliderOption = new ();
+        var eventRaised = false;
+        sliderOption.Set += (sender, args) => eventRaised = true;
+
+        // Act
+        sliderOption.OnSet ();
+
+        // Assert
+        Assert.True (eventRaised);
+    }
+
+    [Fact]
+    public void OnUnSet_Should_Raise_UnSetEvent ()
+    {
+        // Arrange
+        SliderOption<int> sliderOption = new ();
+        var eventRaised = false;
+        sliderOption.UnSet += (sender, args) => eventRaised = true;
+
+        // Act
+        sliderOption.OnUnSet ();
+
+        // Assert
+        Assert.True (eventRaised);
+    }
+
+    [Fact]
+    public void Slider_Option_Default_Constructor ()
+    {
+        SliderOption<int> o = new ();
+        Assert.Null (o.Legend);
+        Assert.Equal (default (Rune), o.LegendAbbr);
+        Assert.Equal (default (int), o.Data);
+    }
+
+    [Fact]
+    public void Slider_Option_Values_Constructor ()
+    {
+        SliderOption<int> o = new ("1 thousand", new ('y'), 1000);
+        Assert.Equal ("1 thousand", o.Legend);
+        Assert.Equal (new ('y'), o.LegendAbbr);
+        Assert.Equal (1000, o.Data);
+    }
+
+    [Fact]
+    public void SliderOption_ToString_WhenEmpty ()
+    {
+        SliderOption<object> sliderOption = new ();
+        Assert.Equal ("{Legend=, LegendAbbr=\0, Data=}", sliderOption.ToString ());
+    }
+
+    [Fact]
+    public void SliderOption_ToString_WhenPopulated_WithInt ()
+    {
+        SliderOption<int> sliderOption = new () { Legend = "Lord flibble", LegendAbbr = new ('l'), Data = 1 };
+
+        Assert.Equal ("{Legend=Lord flibble, LegendAbbr=l, Data=1}", sliderOption.ToString ());
+    }
+
+    [Fact]
+    public void SliderOption_ToString_WhenPopulated_WithSizeF ()
+    {
+        SliderOption<SizeF> sliderOption = new ()
+        {
+            Legend = "Lord flibble", LegendAbbr = new ('l'), Data = new (32, 11)
+        };
+
+        Assert.Equal ("{Legend=Lord flibble, LegendAbbr=l, Data={Width=32, Height=11}}", sliderOption.ToString ());
+    }
+}
+
+public class SliderEventArgsTests : UnitTests.Parallelizable.ParallelizableBase
+{
+    [Fact]
+    public void Constructor_Sets_Cancel_Default_To_False ()
+    {
+        // Arrange
+        Dictionary<int, SliderOption<int>> options = new ();
+        var focused = 42;
+
+        // Act
+        SliderEventArgs<int> sliderEventArgs = new (options, focused);
+
+        // Assert
+        Assert.False (sliderEventArgs.Cancel);
+    }
+
+    [Fact]
+    public void Constructor_Sets_Focused ()
+    {
+        // Arrange
+        Dictionary<int, SliderOption<int>> options = new ();
+        var focused = 42;
+
+        // Act
+        SliderEventArgs<int> sliderEventArgs = new (options, focused);
+
+        // Assert
+        Assert.Equal (focused, sliderEventArgs.Focused);
+    }
+
+    [Fact]
+    public void Constructor_Sets_Options ()
+    {
+        // Arrange
+        Dictionary<int, SliderOption<int>> options = new ();
+
+        // Act
+        SliderEventArgs<int> sliderEventArgs = new (options);
+
+        // Assert
+        Assert.Equal (options, sliderEventArgs.Options);
+    }
+}
+
+public class SliderTests : UnitTests.Parallelizable.ParallelizableBase
+{
+    [Fact]
+    public void Constructor_Default ()
+    {
+        // Arrange & Act
+        Slider<int> slider = new ();
+
+        // Assert
+        Assert.NotNull (slider);
+        Assert.NotNull (slider.Options);
+        Assert.Empty (slider.Options);
+        Assert.Equal (Orientation.Horizontal, slider.Orientation);
+        Assert.False (slider.AllowEmpty);
+        Assert.True (slider.ShowLegends);
+        Assert.False (slider.ShowEndSpacing);
+        Assert.Equal (SliderType.Single, slider.Type);
+        Assert.Equal (1, slider.MinimumInnerSpacing);
+        Assert.True (slider.Width is DimAuto);
+        Assert.True (slider.Height is DimAuto);
+        Assert.Equal (0, slider.FocusedOption);
+    }
+
+    [Fact]
+    public void Constructor_With_Options ()
+    {
+        // Arrange
+        List<int> options = new () { 1, 2, 3 };
+
+        // Act
+        Slider<int> slider = new (options);
+        slider.SetRelativeLayout (new (100, 100));
+
+        // Assert
+        // 0123456789
+        // 1 2 3
+        Assert.Equal (1, slider.MinimumInnerSpacing);
+        Assert.Equal (new Size (5, 2), slider.GetContentSize ());
+        Assert.Equal (new Size (5, 2), slider.Frame.Size);
+        Assert.NotNull (slider);
+        Assert.NotNull (slider.Options);
+        Assert.Equal (options.Count, slider.Options.Count);
+    }
+
+    [Fact]
+    public void MovePlus_Should_MoveFocusRight_When_OptionIsAvailable ()
+    {
+        // Arrange
+        Slider<int> slider = new (new () { 1, 2, 3, 4 });
+
+        // Act
+        bool result = slider.MovePlus ();
+
+        // Assert
+        Assert.True (result);
+        Assert.Equal (1, slider.FocusedOption);
+    }
+
+    [Fact]
+    public void MovePlus_Should_NotMoveFocusRight_When_AtEnd ()
+    {
+        // Arrange
+        Slider<int> slider = new (new () { 1, 2, 3, 4 });
+
+        slider.FocusedOption = 3;
+
+        // Act
+        bool result = slider.MovePlus ();
+
+        // Assert
+        Assert.False (result);
+        Assert.Equal (3, slider.FocusedOption);
+    }
+
+    [Fact]
+    public void OnOptionFocused_Event_Cancelled ()
+    {
+        // Arrange
+        Slider<int> slider = new (new () { 1, 2, 3 });
+        var eventRaised = false;
+        var cancel = false;
+        slider.OptionFocused += (sender, args) => eventRaised = true;
+        var newFocusedOption = 1;
+
+        // Create args with cancel set to false
+        cancel = false;
+
+        SliderEventArgs<int> args =
+            new (new (), newFocusedOption) { Cancel = cancel };
+        Assert.Equal (0, slider.FocusedOption);
+
+        // Act
+        slider.OnOptionFocused (newFocusedOption, args);
+
+        // Assert
+        Assert.True (eventRaised); // Event should be raised
+        Assert.Equal (newFocusedOption, slider.FocusedOption); // Focused option should change
+
+        // Create args with cancel set to true
+        cancel = true;
+
+        args = new (new (), newFocusedOption)
+        {
+            Cancel = cancel
+        };
+
+        // Act
+        slider.OnOptionFocused (2, args);
+
+        // Assert
+        Assert.True (eventRaised); // Event should be raised
+        Assert.Equal (newFocusedOption, slider.FocusedOption); // Focused option should not change
+    }
+
+    [Fact]
+    public void OnOptionFocused_Event_Raised ()
+    {
+        // Arrange
+        Slider<int> slider = new (new () { 1, 2, 3 });
+        var eventRaised = false;
+        slider.OptionFocused += (sender, args) => eventRaised = true;
+        var newFocusedOption = 1;
+        SliderEventArgs<int> args = new (new (), newFocusedOption);
+
+        // Act
+        slider.OnOptionFocused (newFocusedOption, args);
+
+        // Assert
+        Assert.True (eventRaised);
+    }
+
+    [Fact]
+    public void OnOptionsChanged_Event_Raised ()
+    {
+        // Arrange
+        Slider<int> slider = new ();
+        var eventRaised = false;
+        slider.OptionsChanged += (sender, args) => eventRaised = true;
+
+        // Act
+        slider.OnOptionsChanged ();
+
+        // Assert
+        Assert.True (eventRaised);
+    }
+
+    [Fact]
+    public void Set_Should_Not_UnSetFocusedOption_When_EmptyNotAllowed ()
+    {
+        // Arrange
+        Slider<int> slider = new (new () { 1, 2, 3, 4 }) { AllowEmpty = false };
+
+        Assert.NotEmpty (slider.GetSetOptions ());
+
+        // Act
+        bool result = slider.UnSetOption (slider.FocusedOption);
+
+        // Assert
+        Assert.False (result);
+        Assert.NotEmpty (slider.GetSetOptions ());
+    }
+
+    // Add similar tests for other methods like MoveMinus, MoveStart, MoveEnd, Set, etc.
+
+    [Fact]
+    public void Set_Should_SetFocusedOption ()
+    {
+        // Arrange
+        Slider<int> slider = new (new () { 1, 2, 3, 4 });
+
+        // Act
+        slider.FocusedOption = 2;
+        bool result = slider.Select ();
+
+        // Assert
+        Assert.True (result);
+        Assert.Equal (2, slider.FocusedOption);
+        Assert.Single (slider.GetSetOptions ());
+    }
+
+    [Fact]
+    public void TryGetOptionByPosition_InvalidPosition_Failure ()
+    {
+        // Arrange
+        Slider<int> slider = new (new () { 1, 2, 3 });
+        var x = 10;
+        var y = 10;
+        var threshold = 2;
+        int expectedOption = -1;
+
+        // Act
+        bool result = slider.TryGetOptionByPosition (x, y, threshold, out int option);
+
+        // Assert
+        Assert.False (result);
+        Assert.Equal (expectedOption, option);
+    }
+
+    [Theory]
+    [InlineData (0, 0, 0, 1)]
+    [InlineData (3, 0, 0, 2)]
+    [InlineData (9, 0, 0, 4)]
+    [InlineData (0, 0, 1, 1)]
+    [InlineData (3, 0, 1, 2)]
+    [InlineData (9, 0, 1, 4)]
+    public void TryGetOptionByPosition_ValidPositionHorizontal_Success (int x, int y, int threshold, int expectedData)
+    {
+        // Arrange
+        Slider<int> slider = new (new () { 1, 2, 3, 4 });
+        // 0123456789
+        // 1234
+
+        slider.MinimumInnerSpacing = 2;
+
+        // 0123456789
+        // 1--2--3--4
+
+        // Arrange
+
+        // Act
+        bool result = slider.TryGetOptionByPosition (x, y, threshold, out int option);
+
+        // Assert
+        Assert.True (result);
+        Assert.Equal (expectedData, slider.Options [option].Data);
+    }
+
+    [Theory]
+    [InlineData (0, 0, 0, 1)]
+    [InlineData (0, 3, 0, 2)]
+    [InlineData (0, 9, 0, 4)]
+    [InlineData (0, 0, 1, 1)]
+    [InlineData (0, 3, 1, 2)]
+    [InlineData (0, 9, 1, 4)]
+    public void TryGetOptionByPosition_ValidPositionVertical_Success (int x, int y, int threshold, int expectedData)
+    {
+        // Arrange
+        Slider<int> slider = new (new () { 1, 2, 3, 4 });
+        slider.Orientation = Orientation.Vertical;
+
+        // Set auto size to true to enable testing
+        slider.MinimumInnerSpacing = 2;
+
+        // 0 1
+        // 1 |
+        // 2 |
+        // 3 2
+        // 4 |
+        // 5 |
+        // 6 3
+        // 7 |
+        // 8 |
+        // 9 4
+
+        // Act
+        bool result = slider.TryGetOptionByPosition (x, y, threshold, out int option);
+
+        // Assert
+        Assert.True (result);
+        Assert.Equal (expectedData, slider.Options [option].Data);
+    }
+
+    [Fact]
+    public void TryGetPositionByOption_InvalidOption_Failure ()
+    {
+        // Arrange
+        Slider<int> slider = new (new () { 1, 2, 3 });
+        int option = -1;
+        (int, int) expectedPosition = (-1, -1);
+
+        // Act
+        bool result = slider.TryGetPositionByOption (option, out (int x, int y) position);
+
+        // Assert
+        Assert.False (result);
+        Assert.Equal (expectedPosition, position);
+    }
+
+    [Theory]
+    [InlineData (0, 0, 0)]
+    [InlineData (1, 3, 0)]
+    [InlineData (3, 9, 0)]
+    public void TryGetPositionByOption_ValidOptionHorizontal_Success (int option, int expectedX, int expectedY)
+    {
+        // Arrange
+        Slider<int> slider = new (new () { 1, 2, 3, 4 });
+
+        // Set auto size to true to enable testing
+        slider.MinimumInnerSpacing = 2;
+
+        // 0123456789
+        // 1--2--3--4
+
+        // Act
+        bool result = slider.TryGetPositionByOption (option, out (int x, int y) position);
+
+        // Assert
+        Assert.True (result);
+        Assert.Equal (expectedX, position.x);
+        Assert.Equal (expectedY, position.y);
+    }
+
+    [Theory]
+    [InlineData (0, 0, 0)]
+    [InlineData (1, 0, 3)]
+    [InlineData (3, 0, 9)]
+    public void TryGetPositionByOption_ValidOptionVertical_Success (int option, int expectedX, int expectedY)
+    {
+        // Arrange
+        Slider<int> slider = new (new () { 1, 2, 3, 4 });
+        slider.Orientation = Orientation.Vertical;
+
+        // Set auto size to true to enable testing
+        slider.MinimumInnerSpacing = 2;
+
+        // Act
+        bool result = slider.TryGetPositionByOption (option, out (int x, int y) position);
+
+        // Assert
+        Assert.True (result);
+        Assert.Equal (expectedX, position.x);
+        Assert.Equal (expectedY, position.y);
+    }
+
+    // https://github.com/gui-cs/Terminal.Gui/issues/3099
+    [Fact]
+    private void One_Option_Does_Not_Throw ()
+    {
+        // Arrange
+        Slider<int> slider = new ();
+        slider.BeginInit ();
+        slider.EndInit ();
+
+        // Act/Assert
+        slider.Options = new () { new () };
+    }
+
+    [Fact]
+    private void Set_Options_No_Legend_Throws ()
+    {
+        // Arrange
+        Slider<int> slider = new ();
+
+        // Act/Assert
+        Assert.Throws<ArgumentNullException> (() => slider.Options = null);
+    }
+
+    [Fact]
+    private void Set_Options_Throws_If_Null ()
+    {
+        // Arrange
+        Slider<int> slider = new ();
+
+        // Act/Assert
+        Assert.Throws<ArgumentNullException> (() => slider.Options = null);
+    }
+
+    [Fact]
+    private void DimAuto_Both_Respects_SuperView_ContentSize ()
+    {
+        View view = new ()
+        {
+            Width = Dim.Fill (),
+            Height = Dim.Fill ()
+        };
+
+        List<object> options = new () { "01234", "01234" };
+
+        Slider slider = new (options)
+        {
+            Orientation = Orientation.Vertical,
+            Type = SliderType.Multiple,
+        };
+        view.Add (slider);
+        view.BeginInit ();
+        view.EndInit ();
+
+        Size expectedSize = slider.Frame.Size;
+
+        Assert.Equal (new (6, 3), expectedSize);
+
+        view.SetContentSize (new (1, 1));
+
+        view.LayoutSubViews ();
+        slider.SetRelativeLayout (view.Viewport.Size);
+
+        Assert.Equal (expectedSize, slider.Frame.Size);
+    }
+
+    [Fact]
+    private void DimAuto_Width_Respects_SuperView_ContentSize ()
+    {
+        View view = new ()
+        {
+            Width = Dim.Fill (),
+            Height = 10
+        };
+
+        List<object> options = new () { "01234", "01234" };
+
+        Slider slider = new (options)
+        {
+            Orientation = Orientation.Vertical,
+            Type = SliderType.Multiple,
+            Height = 10
+        };
+        view.Add (slider);
+        view.BeginInit ();
+        view.EndInit ();
+
+        Size expectedSize = slider.Frame.Size;
+
+        Assert.Equal (new (6, 10), expectedSize);
+
+        view.SetContentSize (new (1, 1));
+
+        view.LayoutSubViews ();
+        slider.SetRelativeLayout (view.Viewport.Size);
+
+        Assert.Equal (expectedSize, slider.Frame.Size);
+    }
+
+    [Fact]
+    private void DimAuto_Height_Respects_SuperView_ContentSize ()
+    {
+        View view = new ()
+        {
+            Width = 10,
+            Height = Dim.Fill ()
+        };
+
+        List<object> options = new () { "01234", "01234" };
+
+        Slider slider = new (options)
+        {
+            Orientation = Orientation.Vertical,
+            Type = SliderType.Multiple,
+            Width = 10,
+        };
+        view.Add (slider);
+        view.BeginInit ();
+        view.EndInit ();
+
+        Size expectedSize = slider.Frame.Size;
+
+        Assert.Equal (new (10, 3), expectedSize);
+
+        view.SetContentSize (new (1, 1));
+
+        view.LayoutSubViews ();
+        slider.SetRelativeLayout (view.Viewport.Size);
+
+        Assert.Equal (expectedSize, slider.Frame.Size);
+    }
+
+    // Add more tests for different scenarios and edge cases.
+}
--- a/Tests/UnitTestsParallelizable/Views/TextValidateFieldTests.cs
+++ b/Tests/UnitTestsParallelizable/Views/TextValidateFieldTests.cs
@@ -0,0 +1,656 @@
+using System.Text.RegularExpressions;
+
+namespace Terminal.Gui.ViewsTests;
+
+public class TextValidateField_NET_Provider_Tests : UnitTests.Parallelizable.ParallelizableBase
+{
+    [Fact]
+    public void Backspace_Key_Deletes_Previous_Character ()
+    {
+        var field = new TextValidateField
+        {
+            TextAlignment = Alignment.Center,
+            Width = 20,
+
+            //                                             ****
+            //                                          0123456789
+            Provider = new NetMaskedTextProvider ("--(0000)--") { Text = "1234" }
+        };
+
+        // Go to the end.
+        field.NewKeyDownEvent (Key.End);
+
+        field.NewKeyDownEvent (Key.Backspace);
+        Assert.Equal ("--(12_4)--", field.Provider.DisplayText);
+        Assert.False (field.IsValid);
+
+        field.NewKeyDownEvent (Key.Backspace);
+        Assert.Equal ("--(1__4)--", field.Provider.DisplayText);
+        Assert.False (field.IsValid);
+
+        field.NewKeyDownEvent (Key.Backspace);
+        Assert.Equal ("--(___4)--", field.Provider.DisplayText);
+        Assert.False (field.IsValid);
+
+        // One more
+        field.NewKeyDownEvent (Key.Backspace);
+        Assert.Equal ("--(___4)--", field.Provider.DisplayText);
+        Assert.False (field.IsValid);
+    }
+
+    [Fact]
+    public void Changing_The_Mask_Tries_To_Keep_The_Previous_Text ()
+    {
+        var field = new TextValidateField
+        {
+            TextAlignment = Alignment.Start,
+            Width = 30,
+
+            //                                             ****
+            //                                          0123456789
+            Provider = new NetMaskedTextProvider ("--(0000)--")
+        };
+
+        field.Text = "1234";
+        Assert.Equal ("--(1234)--", field.Text);
+        Assert.True (field.IsValid);
+
+        var provider = field.Provider as NetMaskedTextProvider;
+        provider.Mask = "--------(00000000)--------";
+        Assert.Equal ("--------(1234____)--------", field.Provider.DisplayText);
+        Assert.False (field.IsValid);
+    }
+
+    [Fact]
+    public void Default_Width_Is_Always_Equal_To_The_Provider_DisplayText_Length ()
+    {
+        // 9-Digit or space, optional. 0-Digit, required. L-Letter, required.
+        // > Shift up. Converts all characters that follow to uppercase.
+        // | Disable a previous shift up or shift down.
+        // A-Alphanumeric, required. a-Alphanumeric, optional.
+        var field = new TextValidateField { Provider = new NetMaskedTextProvider ("999 000 LLL >LLL |AAA aaa") };
+        field.Layout ();
+        Assert.Equal (field.Viewport.Width, field.Provider.DisplayText.Length);
+        Assert.NotEqual (field.Provider.DisplayText.Length, field.Provider.Text.Length);
+        Assert.Equal (new string (' ', field.Text.Length), field.Provider.Text);
+    }
+
+    [Fact]
+    public void Delete_Key_Doesnt_Move_Cursor ()
+    {
+        var field = new TextValidateField
+        {
+            TextAlignment = Alignment.Center,
+            Width = 20,
+
+            //                                             ****
+            //                                          0123456789
+            Provider = new NetMaskedTextProvider ("--(0000)--") { Text = "1234" }
+        };
+
+        Assert.Equal ("--(1234)--", field.Provider.DisplayText);
+        Assert.True (field.IsValid);
+
+        field.NewKeyDownEvent (Key.Delete);
+        field.NewKeyDownEvent (Key.Delete);
+        field.NewKeyDownEvent (Key.Delete);
+
+        Assert.Equal ("--(_234)--", field.Provider.DisplayText);
+        Assert.False (field.IsValid);
+
+        field.NewKeyDownEvent (Key.CursorRight);
+        field.NewKeyDownEvent (Key.CursorRight);
+
+        field.NewKeyDownEvent (Key.Delete);
+        field.NewKeyDownEvent (Key.Delete);
+        field.NewKeyDownEvent (Key.Delete);
+
+        Assert.Equal ("--(_2_4)--", field.Provider.DisplayText);
+        Assert.False (field.IsValid);
+    }
+
+    [Fact]
+    public void End_Key_Last_Editable_Character ()
+    {
+        var field = new TextValidateField
+        {
+            TextAlignment = Alignment.Center,
+            Width = 20,
+
+            //                                             *
+            //                                          0123456789
+            Provider = new NetMaskedTextProvider ("--(0000)--")
+        };
+
+        field.NewKeyDownEvent (Key.End);
+
+        field.NewKeyDownEvent (Key.D1);
+
+        Assert.Equal ("--(___1)--", field.Provider.DisplayText);
+        Assert.Equal ("--(   1)--", field.Text);
+        Assert.False (field.IsValid);
+    }
+
+    [Fact]
+    public void Home_Key_First_Editable_Character ()
+    {
+        var field = new TextValidateField
+        {
+            TextAlignment = Alignment.Center,
+            Width = 20,
+
+            //                                             *
+            //                                          0123456789
+            Provider = new NetMaskedTextProvider ("--(0000)--")
+        };
+
+        field.NewKeyDownEvent (Key.CursorRight);
+        field.NewKeyDownEvent (Key.CursorRight);
+        field.NewKeyDownEvent (Key.Home);
+
+        field.NewKeyDownEvent (Key.D1);
+
+        Assert.Equal ("--(1___)--", field.Provider.DisplayText);
+        Assert.Equal ("--(1   )--", field.Text);
+        Assert.False (field.IsValid);
+    }
+
+    [Fact]
+    public void Initial_Value_Bigger_Than_Mask_Discarded ()
+    {
+        var field = new TextValidateField
+        {
+            TextAlignment = Alignment.Center,
+            Width = 20,
+
+            //                                             ****
+            //                                          0123456789
+            Provider = new NetMaskedTextProvider ("--(0000)--") { Text = "12345" }
+        };
+
+        Assert.Equal ("--(____)--", field.Provider.DisplayText);
+        Assert.Equal ("--(    )--", field.Text);
+        Assert.False (field.IsValid);
+    }
+
+    [Fact]
+    public void Initial_Value_Exact_Valid ()
+    {
+        var field = new TextValidateField
+        {
+            TextAlignment = Alignment.Center,
+            Width = 20,
+
+            //                                             ****
+            //                                          0123456789
+            Provider = new NetMaskedTextProvider ("--(0000)--") { Text = "1234" }
+        };
+
+        Assert.Equal ("--(1234)--", field.Text);
+        Assert.True (field.IsValid);
+    }
+
+    [Fact]
+    public void Initial_Value_Smaller_Than_Mask_Accepted ()
+    {
+        var field = new TextValidateField
+        {
+            TextAlignment = Alignment.Center,
+            Width = 20,
+
+            //                                             ****
+            //                                          0123456789
+            Provider = new NetMaskedTextProvider ("--(0000)--") { Text = "123" }
+        };
+
+        Assert.Equal ("--(123_)--", field.Provider.DisplayText);
+        Assert.Equal ("--(123 )--", field.Text);
+        Assert.False (field.IsValid);
+    }
+
+    [Fact]
+    public void Initialized_With_Cursor_On_First_Editable_Character ()
+    {
+        var field = new TextValidateField
+        {
+            TextAlignment = Alignment.Center,
+            Width = 20,
+
+            //                                             *
+            //                                          0123456789
+            Provider = new NetMaskedTextProvider ("--(0000)--")
+        };
+
+        field.NewKeyDownEvent (Key.D1);
+
+        Assert.Equal ("--(1___)--", field.Provider.DisplayText);
+        Assert.Equal ("--(1   )--", field.Text);
+    }
+
+    [Fact]
+    public void Input_Ilegal_Character ()
+    {
+        var field = new TextValidateField
+        {
+            TextAlignment = Alignment.Center,
+            Width = 20,
+
+            //                                             *
+            //                                          0123456789
+            Provider = new NetMaskedTextProvider ("--(0000)--")
+        };
+
+        field.NewKeyDownEvent (Key.A);
+
+        Assert.Equal ("--(    )--", field.Text);
+        Assert.Equal ("--(____)--", field.Provider.DisplayText);
+        Assert.False (field.IsValid);
+    }
+
+    [Fact]
+    public void Insert_Skips_Non_Editable_Characters ()
+    {
+        var field = new TextValidateField
+        {
+            TextAlignment = Alignment.Center,
+            Width = 20,
+
+            //                                             ** **
+            //                                          01234567890
+            Provider = new NetMaskedTextProvider ("--(00-00)--")
+        };
+
+        field.NewKeyDownEvent (Key.D1);
+        Assert.Equal ("--(1_-__)--", field.Provider.DisplayText);
+        Assert.False (field.IsValid);
+
+        field.NewKeyDownEvent (Key.D2);
+        Assert.Equal ("--(12-__)--", field.Provider.DisplayText);
+        Assert.False (field.IsValid);
+
+        field.NewKeyDownEvent (Key.D3);
+        Assert.Equal ("--(12-3_)--", field.Provider.DisplayText);
+        Assert.False (field.IsValid);
+
+        field.NewKeyDownEvent (Key.D4);
+        Assert.Equal ("--(12-34)--", field.Provider.DisplayText);
+        Assert.True (field.IsValid);
+    }
+
+    [Fact]
+    public void Left_Key_Stops_In_First_Editable_Character ()
+    {
+        var field = new TextValidateField
+        {
+            TextAlignment = Alignment.Center,
+            Width = 20,
+
+            //                                             *
+            //                                          0123456789
+            Provider = new NetMaskedTextProvider ("--(0000)--")
+        };
+
+        for (var i = 0; i < 10; i++)
+        {
+            field.NewKeyDownEvent (Key.CursorLeft);
+        }
+
+        field.NewKeyDownEvent (Key.D1);
+
+        Assert.Equal ("--(1___)--", field.Provider.DisplayText);
+        Assert.Equal ("--(1   )--", field.Text);
+        Assert.False (field.IsValid);
+    }
+
+    [Fact]
+    public void MouseClick_Right_X_Greater_Than_Text_Width_Goes_To_Last_Editable_Position ()
+    {
+        var field = new TextValidateField
+        {
+            TextAlignment = Alignment.Start,
+            Width = 30,
+
+            //                                             ****
+            //                                          0123456789
+            Provider = new NetMaskedTextProvider ("--(0000)--")
+        };
+
+        field.NewKeyDownEvent (Key.D1);
+
+        Assert.Equal ("--(1___)--", field.Provider.DisplayText);
+        Assert.False (field.IsValid);
+        Assert.Equal ("--(1   )--", field.Provider.Text);
+
+        field.NewMouseEvent (new MouseEventArgs { Position = new (25, 0), Flags = MouseFlags.Button1Pressed });
+
+        field.NewKeyDownEvent (Key.D1);
+
+        Assert.Equal ("--(1__1)--", field.Provider.DisplayText);
+        Assert.False (field.IsValid);
+        Assert.Equal ("--(1  1)--", field.Provider.Text);
+    }
+
+    [Fact]
+    public void OnTextChanged_TextChanged_Event ()
+    {
+        var wasTextChanged = false;
+
+        var field = new TextValidateField
+        {
+            TextAlignment = Alignment.Start, Width = 30, Provider = new NetMaskedTextProvider ("--(0000)--")
+        };
+
+        field.Provider.TextChanged += (sender, e) => wasTextChanged = true;
+
+        field.NewKeyDownEvent (Key.D1);
+
+        Assert.Equal ("--(1___)--", field.Provider.DisplayText);
+        Assert.False (field.IsValid);
+        Assert.Equal ("--(1   )--", field.Provider.Text);
+        Assert.True (wasTextChanged);
+    }
+
+    [Fact]
+    public void Right_Key_Stops_In_Last_Editable_Character ()
+    {
+        var field = new TextValidateField
+        {
+            TextAlignment = Alignment.Center,
+            Width = 20,
+
+            //                                             *
+            //                                          0123456789
+            Provider = new NetMaskedTextProvider ("--(0000)--")
+        };
+
+        for (var i = 0; i < 10; i++)
+        {
+            field.NewKeyDownEvent (Key.CursorRight);
+        }
+
+        field.NewKeyDownEvent (Key.D1);
+
+        Assert.Equal ("--(___1)--", field.Provider.DisplayText);
+        Assert.Equal ("--(   1)--", field.Text);
+        Assert.False (field.IsValid);
+    }
+
+    [Fact]
+    public void Set_Text_After_Initialization ()
+    {
+        var field = new TextValidateField
+        {
+            TextAlignment = Alignment.Start,
+            Width = 30,
+
+            //                                             ****
+            //                                          0123456789
+            Provider = new NetMaskedTextProvider ("--(0000)--")
+        };
+
+        field.Text = "1234";
+
+        Assert.Equal ("--(1234)--", field.Text);
+        Assert.True (field.IsValid);
+    }
+
+    [Fact]
+    public void When_Valid_Is_Valid_True ()
+    {
+        var field = new TextValidateField
+        {
+            TextAlignment = Alignment.Center,
+            Width = 20,
+
+            //                                             ****
+            //                                          0123456789
+            Provider = new NetMaskedTextProvider ("--(0000)--")
+        };
+
+        field.NewKeyDownEvent (Key.D1);
+        Assert.Equal ("--(1   )--", field.Text);
+        Assert.False (field.IsValid);
+
+        field.NewKeyDownEvent (Key.D2);
+        Assert.Equal ("--(12  )--", field.Text);
+        Assert.False (field.IsValid);
+
+        field.NewKeyDownEvent (Key.D3);
+        Assert.Equal ("--(123 )--", field.Text);
+        Assert.False (field.IsValid);
+
+        field.NewKeyDownEvent (Key.D4);
+        Assert.Equal ("--(1234)--", field.Text);
+        Assert.True (field.IsValid);
+    }
+}
+
+public class TextValidateField_Regex_Provider_Tests : UnitTests.Parallelizable.ParallelizableBase
+{
+    [Fact]
+    public void End_Key_End_Of_Input ()
+    {
+        // Exactly 5 numbers
+        var field = new TextValidateField
+        {
+            Width = 20, Provider = new TextRegexProvider ("^[0-9]{5}$") { ValidateOnInput = false }
+        };
+
+        for (var i = 0; i < 4; i++)
+        {
+            field.NewKeyDownEvent (Key.D0);
+        }
+
+        Assert.Equal ("0000", field.Text);
+        Assert.False (field.IsValid);
+
+        // HOME KEY
+        field.NewKeyDownEvent (Key.Home);
+
+        // END KEY
+        field.NewKeyDownEvent (Key.End);
+
+        // Insert 9
+        field.NewKeyDownEvent (Key.D9);
+
+        Assert.Equal ("00009", field.Text);
+        Assert.True (field.IsValid);
+
+        // Insert 9
+        field.NewKeyDownEvent (Key.D9);
+
+        Assert.Equal ("000099", field.Text);
+        Assert.False (field.IsValid);
+    }
+
+    [Fact]
+    public void Home_Key_First_Editable_Character ()
+    {
+        // Range 0 to 1000
+        // Accepts 001 too.
+        var field = new TextValidateField { Width = 20, Provider = new TextRegexProvider ("^[0-9]?[0-9]?[0-9]|1000$") };
+
+        field.NewKeyDownEvent (Key.D1);
+        field.NewKeyDownEvent (Key.D0);
+        field.NewKeyDownEvent (Key.D0);
+        field.NewKeyDownEvent (Key.D0);
+
+        Assert.Equal ("1000", field.Text);
+        Assert.True (field.IsValid);
+
+        // HOME KEY
+        field.NewKeyDownEvent (Key.Home);
+
+        // DELETE
+        field.NewKeyDownEvent (Key.Delete);
+
+        Assert.Equal ("000", field.Text);
+        Assert.True (field.IsValid);
+    }
+
+    [Fact]
+    public void Input_With_Validate_On_Input_Set_Text ()
+    {
+        var field = new TextValidateField { Width = 20, Provider = new TextRegexProvider ("^[0-9][0-9][0-9]$") };
+
+        // Input dosen't validates the pattern.
+        field.NewKeyDownEvent (Key.D1);
+        Assert.Equal ("", field.Text);
+        Assert.False (field.IsValid);
+
+        // Dosen't match
+        field.Text = "12356";
+        Assert.Equal ("", field.Text);
+        Assert.False (field.IsValid);
+
+        // Yes.
+        field.Text = "123";
+        Assert.Equal ("123", field.Text);
+        Assert.True (field.IsValid);
+    }
+
+    [Fact]
+    public void Input_Without_Validate_On_Input ()
+    {
+        var field = new TextValidateField
+        {
+            Width = 20, Provider = new TextRegexProvider ("^[0-9][0-9][0-9]$") { ValidateOnInput = false }
+        };
+
+        field.NewKeyDownEvent (Key.D1);
+        Assert.Equal ("1", field.Text);
+        Assert.False (field.IsValid);
+
+        field.NewKeyDownEvent (Key.D2);
+        Assert.Equal ("12", field.Text);
+        Assert.False (field.IsValid);
+
+        field.NewKeyDownEvent (Key.D3);
+        Assert.Equal ("123", field.Text);
+        Assert.True (field.IsValid);
+
+        field.NewKeyDownEvent (Key.D4);
+        Assert.Equal ("1234", field.Text);
+        Assert.False (field.IsValid);
+    }
+
+    [Fact]
+    public void Left_Key_Stops_At_Start_And_Insert ()
+    {
+        var field = new TextValidateField
+        {
+            TextAlignment = Alignment.Center,
+            Width = 20,
+            Provider = new TextRegexProvider ("^[0-9][0-9][0-9]$") { ValidateOnInput = false }
+        };
+
+        field.Text = "123";
+
+        for (var i = 0; i < 10; i++)
+        {
+            field.NewKeyDownEvent (Key.CursorLeft);
+        }
+
+        Assert.Equal ("123", field.Text);
+        Assert.True (field.IsValid);
+
+        // Insert 4
+        field.NewKeyDownEvent (Key.D4);
+
+        Assert.Equal ("4123", field.Text);
+        Assert.False (field.IsValid);
+    }
+
+    [Fact]
+    public void Mask_With_Invalid_Pattern_Exception ()
+    {
+        // Regex Exception
+        // Maybe it's not the right behaviour.
+
+        var mask = "";
+
+        for (var i = 0; i < 255; i++)
+        {
+            mask += (char)i;
+        }
+
+        try
+        {
+            var field = new TextValidateField { Width = 20, Provider = new TextRegexProvider (mask) };
+        }
+        catch (RegexParseException ex)
+        {
+            Assert.True (true, ex.Message);
+
+            return;
+        }
+
+        Assert.True (false);
+    }
+
+    [Fact]
+    public void OnTextChanged_TextChanged_Event ()
+    {
+        var wasTextChanged = false;
+
+        var field = new TextValidateField
+        {
+            TextAlignment = Alignment.Center,
+            Width = 20,
+            Provider = new TextRegexProvider ("^[0-9][0-9][0-9]$") { ValidateOnInput = false }
+        };
+
+        field.Provider.TextChanged += (sender, e) => wasTextChanged = true;
+
+        field.NewKeyDownEvent (Key.D1);
+
+        Assert.Equal ("1", field.Provider.DisplayText);
+        Assert.False (field.IsValid);
+        Assert.Equal ("1", field.Provider.Text);
+        Assert.True (wasTextChanged);
+    }
+
+    [Fact]
+    public void Right_Key_Stops_At_End_And_Insert ()
+    {
+        var field = new TextValidateField
+        {
+            TextAlignment = Alignment.Center,
+            Width = 20,
+            Provider = new TextRegexProvider ("^[0-9][0-9][0-9]$") { ValidateOnInput = false }
+        };
+
+        field.Text = "123";
+
+        for (var i = 0; i < 10; i++)
+        {
+            field.NewKeyDownEvent (Key.CursorRight);
+        }
+
+        Assert.Equal ("123", field.Text);
+        Assert.True (field.IsValid);
+
+        // Insert 4
+        field.NewKeyDownEvent (Key.D4);
+
+        Assert.Equal ("1234", field.Text);
+        Assert.False (field.IsValid);
+    }
+
+    [Fact]
+    public void Text_With_All_Charset ()
+    {
+        var field = new TextValidateField { Width = 20, Provider = new TextRegexProvider ("^[0-9][0-9][0-9]$") };
+
+        var text = "";
+
+        for (var i = 0; i < 255; i++)
+        {
+            text += (char)i;
+        }
+
+        field.Text = text;
+
+        Assert.False (field.IsValid);
+    }
+}