Resolving merge conflicts.

UnitTests/View/Adornment/AdornmentTests.cs

@@ -381,4 +381,116 @@ public class AdornmentTests (ITestOutputHelper output)
         view.Padding.Thickness = new (2, 2, 2, 2);
         Assert.Throws<InvalidOperationException> (() => view.Padding.Viewport = view.Padding.Viewport with { Location = new (1, 1) });
     }
+
+    // Contains tests
+
+    [Theory]
+    [InlineData (0, 0, 0, 0, 0, 0, false)]
+    [InlineData (0, 0, 0, 1, 0, 0, false)]
+    [InlineData (0, 0, 1, 0, 0, 0, false)]
+    [InlineData (0, 0, 1, 1, 0, 0, true)]
+    [InlineData (0, 0, 1, 2, 0, 0, true)]
+
+    [InlineData (1, 1, 0, 0, 0, 0, false)]
+    [InlineData (1, 1, 0, 1, 0, 0, false)]
+    [InlineData (1, 1, 1, 0, 0, 0, false)]
+    [InlineData (1, 1, 1, 0, 0, 1, false)]
+    [InlineData (1, 1, 1, 1, 1, 0, false)]
+    [InlineData (1, 1, 1, 1, 0, 0, false)]
+    [InlineData (1, 1, 1, 1, 1, 1, true)]
+    [InlineData (1, 1, 1, 2, 1, 1, true)]
+    public void Contains_Left_Only (int x, int y, int width, int height, int pointX, int pointY, bool expected)
+    {
+        Adornment adornment = new () { Id = "adornment" };
+        adornment.Parent = new View () { Id = "parent" };
+        adornment.Parent.Frame = new Rectangle (x, y, width, height);
+        adornment.Thickness = new (1, 0, 0, 0);
+        adornment.Frame = adornment.Parent.Frame with { Location = Point.Empty };
+
+        bool result = adornment.Contains (new (pointX, pointY));
+        Assert.Equal (expected, result);
+    }
+
+    [Theory]
+    [InlineData (0, 0, 0, 0, 0, 0, false)]
+    [InlineData (0, 0, 0, 1, 0, 0, false)]
+    [InlineData (0, 0, 1, 0, 0, 0, false)]
+    [InlineData (0, 0, 1, 1, 0, 0, true)]
+    [InlineData (0, 0, 1, 2, 0, 0, true)]
+
+    [InlineData (1, 1, 0, 0, 0, 0, false)]
+    [InlineData (1, 1, 0, 1, 0, 0, false)]
+    [InlineData (1, 1, 1, 0, 0, 0, false)]
+    [InlineData (1, 1, 1, 0, 0, 1, false)]
+    [InlineData (1, 1, 1, 1, 1, 0, false)]
+    [InlineData (1, 1, 1, 1, 0, 0, false)]
+    [InlineData (1, 1, 1, 1, 1, 1, true)]
+    [InlineData (1, 1, 1, 2, 1, 1, true)]
+    public void Contains_Right_Only (int x, int y, int width, int height, int pointX, int pointY, bool expected)
+    {
+        Adornment adornment = new () { Id = "adornment" };
+        adornment.Parent = new View () { Id = "parent" };
+        adornment.Parent.Frame = new Rectangle (x, y, width, height);
+        adornment.Thickness = new (0, 0, 1, 0);
+        adornment.Frame = adornment.Parent.Frame with { Location = Point.Empty };
+
+        bool result = adornment.Contains (new (pointX, pointY));
+        Assert.Equal (expected, result);
+    }
+
+
+    [Theory]
+    [InlineData (0, 0, 0, 0, 0, 0, false)]
+    [InlineData (0, 0, 0, 1, 0, 0, false)]
+    [InlineData (0, 0, 1, 0, 0, 0, false)]
+    [InlineData (0, 0, 1, 1, 0, 0, true)]
+    [InlineData (0, 0, 1, 2, 0, 0, true)]
+
+    [InlineData (1, 1, 0, 0, 0, 0, false)]
+    [InlineData (1, 1, 0, 1, 0, 0, false)]
+    [InlineData (1, 1, 1, 0, 0, 0, false)]
+    [InlineData (1, 1, 1, 0, 0, 1, false)]
+    [InlineData (1, 1, 1, 1, 1, 0, false)]
+    [InlineData (1, 1, 1, 1, 0, 0, false)]
+    [InlineData (1, 1, 1, 1, 1, 1, true)]
+    [InlineData (1, 1, 1, 2, 1, 1, true)]
+    public void Contains_Top_Only (int x, int y, int width, int height, int pointX, int pointY, bool expected)
+    {
+        Adornment adornment = new () { Id = "adornment" };
+        adornment.Parent = new View () { Id = "parent" };
+        adornment.Parent.Frame = new Rectangle (x, y, width, height);
+        adornment.Thickness = new (0, 1, 0, 0);
+        adornment.Frame = adornment.Parent.Frame with { Location = Point.Empty };
+
+        bool result = adornment.Contains (new (pointX, pointY));
+        Assert.Equal (expected, result);
+    }
+
+
+    [Theory]
+    [InlineData (0, 0, 0, 0, 0, 0, false)]
+    [InlineData (0, 0, 0, 1, 0, 0, false)]
+    [InlineData (0, 0, 1, 0, 0, 0, false)]
+    [InlineData (0, 0, 1, 1, 0, 0, true)]
+    [InlineData (0, 0, 1, 2, 0, 0, true)]
+
+    [InlineData (1, 1, 0, 0, 0, 0, false)]
+    [InlineData (1, 1, 0, 1, 0, 0, false)]
+    [InlineData (1, 1, 1, 0, 0, 0, false)]
+    [InlineData (1, 1, 1, 0, 0, 1, false)]
+    [InlineData (1, 1, 1, 1, 1, 0, false)]
+    [InlineData (1, 1, 1, 1, 0, 0, false)]
+    [InlineData (1, 1, 1, 1, 1, 1, true)]
+    [InlineData (1, 1, 1, 2, 1, 1, true)]
+    public void Contains_TopLeft_Only (int x, int y, int width, int height, int pointX, int pointY, bool expected)
+    {
+        Adornment adornment = new () { Id = "adornment" };
+        adornment.Parent = new View () { Id = "parent" };
+        adornment.Parent.Frame = new Rectangle (x, y, width, height);
+        adornment.Thickness = new (1, 1, 0, 0);
+        adornment.Frame = adornment.Parent.Frame with { Location = Point.Empty };
+
+        bool result = adornment.Contains (new (pointX, pointY));
+        Assert.Equal (expected, result);
+    }
 }

UnitTests/View/HotKeyTests.cs

@@ -341,4 +341,46 @@ public class HotKeyTests
         Assert.Equal ("", view.Title);
         Assert.Equal (KeyCode.Null, view.HotKey);
     }
+
+
+    [Fact]
+    public void HotKey_Raises_HotKeyCommand ()
+    {
+        var hotKeyRaised = false;
+        var acceptRaised = false;
+        var selectRaised = false;
+        Application.Top = new Toplevel ();
+        var view = new View
+        {
+            CanFocus = true,
+            HotKeySpecifier = new Rune ('_'),
+            Title = "_Test"
+        };
+        Application.Top.Add (view);
+        view.HandlingHotKey += (s, e) => hotKeyRaised = true;
+        view.Accepting += (s, e) => acceptRaised = true;
+        view.Selecting += (s, e) => selectRaised = true;
+
+        Assert.Equal (KeyCode.T, view.HotKey);
+        Assert.True (Application.OnKeyDown (Key.T)); 
+        Assert.True (hotKeyRaised);
+        Assert.False (acceptRaised);
+        Assert.False (selectRaised);
+
+        hotKeyRaised = false;
+        Assert.True (Application.OnKeyDown (Key.T.WithAlt));
+        Assert.True (hotKeyRaised);
+        Assert.False (acceptRaised);
+        Assert.False (selectRaised);
+
+        hotKeyRaised = false;
+        view.HotKey = KeyCode.E;
+        Assert.True (Application.OnKeyDown (Key.E.WithAlt));
+        Assert.True (hotKeyRaised);
+        Assert.False (acceptRaised);
+        Assert.False (selectRaised);
+
+        Application.Top.Dispose ();
+        Application.ResetState (true);
+    }
 }

UnitTests/View/Mouse/MouseTests.cs

@@ -33,6 +33,38 @@ public class MouseTests (ITestOutputHelper output) : TestsAllViews
         Assert.Equal (expectedHasFocus, testView.HasFocus);
     }
 
+
+    [Theory]
+    [InlineData (false, false, 1)]
+    [InlineData (true, false, 1)]
+    [InlineData (true, true, 1)]
+    public void MouseClick_Raises_Selecting (bool canFocus, bool setFocus, int expectedSelectingCount)
+    {
+        var superView = new View { CanFocus = true, Height = 1, Width = 15 };
+        var focusedView = new View { CanFocus = true, Width = 1, Height = 1 };
+        var testView = new View { CanFocus = canFocus, X = 4, Width = 4, Height = 1 };
+        superView.Add (focusedView, testView);
+
+        focusedView.SetFocus ();
+
+        Assert.True (superView.HasFocus);
+        Assert.True (focusedView.HasFocus);
+        Assert.False (testView.HasFocus);
+
+        if (setFocus)
+        {
+            testView.SetFocus ();
+        }
+
+        int selectingCount = 0;
+        testView.Selecting += (sender, args) => selectingCount++;
+
+        testView.NewMouseEvent (new () { Position = new (0, 0), Flags = MouseFlags.Button1Clicked });
+        Assert.True (superView.HasFocus);
+        Assert.Equal (expectedSelectingCount, selectingCount);
+    }
+
+
     // TODO: Add more tests that ensure the above test works with positive adornments
 
     // Test drag to move
@@ -74,9 +106,9 @@ public class MouseTests (ITestOutputHelper output) : TestsAllViews
         Application.Begin (top);
 
         Assert.Equal (new Point (4, 4), testView.Frame.Location);
-        Application.OnMouseEvent (new () { Position = new (xy, xy), Flags = MouseFlags.Button1Pressed });
+        Application.OnMouseEvent (new () { ScreenPosition = new (xy, xy), Flags = MouseFlags.Button1Pressed });
 
-        Application.OnMouseEvent (new () { Position = new (xy + 1, xy + 1), Flags = MouseFlags.Button1Pressed | MouseFlags.ReportMousePosition });
+        Application.OnMouseEvent (new () { ScreenPosition = new (xy + 1, xy + 1), Flags = MouseFlags.Button1Pressed | MouseFlags.ReportMousePosition });
 
         Assert.Equal (expectedMoved, new Point (5, 5) == testView.Frame.Location);
         top.Dispose ();
@@ -207,7 +239,7 @@ public class MouseTests (ITestOutputHelper output) : TestsAllViews
     [InlineData (MouseFlags.Button2Clicked)]
     [InlineData (MouseFlags.Button3Clicked)]
     [InlineData (MouseFlags.Button4Clicked)]
-    public void WantContinuousButtonPressed_True_Button_Clicked_Clicks (MouseFlags clicked)
+    public void WantContinuousButtonPressed_True_Button_Clicked_Raises_MouseClick (MouseFlags clicked)
     {
         var me = new MouseEvent ();
 
@@ -229,6 +261,34 @@ public class MouseTests (ITestOutputHelper output) : TestsAllViews
         view.Dispose ();
     }
 
+
+    [Theory]
+    [InlineData (MouseFlags.Button1Clicked)]
+    [InlineData (MouseFlags.Button2Clicked)]
+    [InlineData (MouseFlags.Button3Clicked)]
+    [InlineData (MouseFlags.Button4Clicked)]
+    public void WantContinuousButtonPressed_True_Button_Clicked_Raises_Selecting (MouseFlags clicked)
+    {
+        var me = new MouseEvent ();
+
+        var view = new View ()
+        {
+            Width = 1,
+            Height = 1,
+            WantContinuousButtonPressed = true
+        };
+
+        var selectingCount = 0;
+
+        view.Selecting += (s, e) => selectingCount++;
+
+        me.Flags = clicked;
+        view.NewMouseEvent (me);
+        Assert.Equal (1, selectingCount);
+
+        view.Dispose ();
+    }
+
     [Theory]
     [InlineData (MouseFlags.Button1Pressed, MouseFlags.Button1Released)]
     [InlineData (MouseFlags.Button2Pressed, MouseFlags.Button2Released)]

UnitTests/View/Navigation/EnabledTests.cs

@@ -258,7 +258,7 @@ public class EnabledTests () : TestsAllViews
         var wasClicked = false;
         var button = new Button { Text = "Click Me" };
         button.IsDefault = true;
-        button.Accept += (s, e) => wasClicked = !wasClicked;
+        button.Accepting += (s, e) => wasClicked = !wasClicked;
         var win = new Window { Width = Dim.Fill (), Height = Dim.Fill () };
         win.Add (button);
         var top = new Toplevel ();

UnitTests/View/Navigation/HasFocusTests.cs

@@ -80,7 +80,7 @@ public class HasFocusTests () : TestsAllViews
     {
         var wasClicked = false;
         var view = new Button { Text = "Click Me" };
-        view.Accept += (s, e) => wasClicked = !wasClicked;
+        view.Accepting += (s, e) => wasClicked = !wasClicked;
 
         view.NewKeyDownEvent (Key.Space);
         Assert.True (wasClicked);

UnitTests/View/Navigation/NavigationTests.cs

@@ -61,6 +61,12 @@ public class NavigationTests (ITestOutputHelper _output) : TestsAllViews
                 case TabBehavior.TabGroup:
                     Application.OnKeyDown (key);
 
+                    if (view.HasFocus)
+                    {
+                        // Try once more (HexView)
+                        Application.OnKeyDown (key);
+                    }
+
                     break;
                 default:
                     Application.OnKeyDown (Key.Tab);
@@ -129,21 +135,24 @@ public class NavigationTests (ITestOutputHelper _output) : TestsAllViews
         var hasFocusFalse = 0;
 
         view.HasFocusChanged += (s, e) =>
-                                {
-                                    if (e.NewValue)
-                                    {
-                                        hasFocusTrue++;
-                                    }
-                                    else
-                                    {
-                                        hasFocusFalse++;
-                                    }
-                                };
+        {
+            if (e.NewValue)
+            {
+                hasFocusTrue++;
+            }
+            else
+            {
+                hasFocusFalse++;
+            }
+        };
 
         top.Add (view, otherView);
         Assert.False (view.HasFocus);
         Assert.False (otherView.HasFocus);
 
+        // Ensure the view is Visible
+        view.Visible = true;
+
         Application.Top.SetFocus ();
         Assert.True (Application.Top!.HasFocus);
         Assert.True (top.HasFocus);

UnitTests/View/ViewCommandTests.cs

@@ -0,0 +1,302 @@
+using System.ComponentModel;
+using System.Text;
+using Xunit.Abstractions;
+
+namespace Terminal.Gui.ViewTests;
+
+public class ViewCommandTests (ITestOutputHelper output)
+{
+    #region OnAccept/Accept tests
+    [Fact]
+    public void Accept_Command_Raises_NoFocus ()
+    {
+        var view = new ViewEventTester ();
+        Assert.False (view.HasFocus);
+
+        Assert.False (view.InvokeCommand (Command.Accept)); // false means it was not handled
+
+        Assert.Equal (1, view.OnAcceptedCount);
+
+        Assert.Equal (1, view.AcceptedCount);
+
+        Assert.False (view.HasFocus);
+    }
+
+    [Fact]
+    public void Accept_Command_Handle_OnAccept_NoEvent ()
+    {
+        var view = new ViewEventTester ();
+        Assert.False (view.HasFocus);
+
+        view.HandleOnAccepted = true;
+        Assert.True (view.InvokeCommand (Command.Accept));
+
+        Assert.Equal (1, view.OnAcceptedCount);
+
+        Assert.Equal (0, view.AcceptedCount);
+    }
+
+    [Fact]
+    public void Accept_Handle_Event_OnAccept_Returns_True ()
+    {
+        var view = new View ();
+        var acceptInvoked = false;
+
+        view.Accepting += ViewOnAccept;
+
+        bool? ret = view.InvokeCommand (Command.Accept);
+        Assert.True (ret);
+        Assert.True (acceptInvoked);
+
+        return;
+
+        void ViewOnAccept (object sender, CommandEventArgs e)
+        {
+            acceptInvoked = true;
+            e.Cancel = true;
+        }
+    }
+
+    [Fact]
+    public void Accept_Command_Invokes_Accept_Event ()
+    {
+        var view = new View ();
+        var accepted = false;
+
+        view.Accepting += ViewOnAccept;
+
+        view.InvokeCommand (Command.Accept);
+        Assert.True (accepted);
+
+        return;
+
+        void ViewOnAccept (object sender, CommandEventArgs e) { accepted = true; }
+    }
+
+    // Accept on subview should bubble up to parent
+    [Fact]
+    public void Accept_Command_Bubbles_Up_To_SuperView ()
+    {
+        var view = new ViewEventTester () { Id = "view" };
+        var subview = new ViewEventTester () { Id = "subview" };
+        view.Add (subview);
+
+        subview.InvokeCommand (Command.Accept);
+        Assert.Equal (1, subview.OnAcceptedCount);
+        Assert.Equal (1, view.OnAcceptedCount);
+
+        subview.HandleOnAccepted = true;
+        subview.InvokeCommand (Command.Accept);
+        Assert.Equal (2, subview.OnAcceptedCount);
+        Assert.Equal (1, view.OnAcceptedCount);
+
+        subview.HandleOnAccepted = false;
+        subview.HandleAccepted = true;
+        subview.InvokeCommand (Command.Accept);
+        Assert.Equal (3, subview.OnAcceptedCount);
+        Assert.Equal (1, view.OnAcceptedCount);
+
+        // Add a super view to test deeper hierarchy
+        var superView = new ViewEventTester () { Id = "superView" };
+        superView.Add (view);
+
+        subview.InvokeCommand (Command.Accept);
+        Assert.Equal (4, subview.OnAcceptedCount);
+        Assert.Equal (1, view.OnAcceptedCount);
+        Assert.Equal (0, superView.OnAcceptedCount);
+
+        subview.HandleAccepted = false;
+        subview.InvokeCommand (Command.Accept);
+        Assert.Equal (5, subview.OnAcceptedCount);
+        Assert.Equal (2, view.OnAcceptedCount);
+        Assert.Equal (1, superView.OnAcceptedCount);
+
+        view.HandleAccepted = true;
+        subview.InvokeCommand (Command.Accept);
+        Assert.Equal (6, subview.OnAcceptedCount);
+        Assert.Equal (3, view.OnAcceptedCount);
+        Assert.Equal (1, superView.OnAcceptedCount);
+    }
+
+    [Fact]
+    public void MouseClick_Does_Not_Invoke_Accept_Command ()
+    {
+        var view = new ViewEventTester ();
+        view.NewMouseEvent (new () { Flags = MouseFlags.Button1Clicked, Position = Point.Empty, View = view });
+
+        Assert.Equal (0, view.OnAcceptedCount);
+    }
+
+    #endregion OnAccept/Accept tests
+
+    #region OnSelect/Select tests
+
+    [Theory]
+    [CombinatorialData]
+    public void Select_Command_Raises_SetsFocus (bool canFocus)
+    {
+        var view = new ViewEventTester ()
+        {
+            CanFocus = canFocus
+        };
+
+        Assert.Equal (canFocus, view.CanFocus);
+        Assert.False (view.HasFocus);
+
+        Assert.Equal (canFocus, view.InvokeCommand (Command.Select));
+
+        Assert.Equal (1, view.OnSelectingCount);
+
+        Assert.Equal (1, view.SelectingCount);
+
+        Assert.Equal (canFocus, view.HasFocus);
+    }
+
+    [Fact]
+    public void Select_Command_Handle_OnSelecting_NoEvent ()
+    {
+        var view = new ViewEventTester ();
+        Assert.False (view.HasFocus);
+
+        view.HandleOnSelecting = true;
+        Assert.True (view.InvokeCommand (Command.Select));
+
+        Assert.Equal (1, view.OnSelectingCount);
+
+        Assert.Equal (0, view.SelectingCount);
+    }
+
+    [Fact]
+    public void Select_Handle_Event_OnSelecting_Returns_True ()
+    {
+        var view = new View ();
+        var SelectingInvoked = false;
+
+        view.Selecting += ViewOnSelect;
+
+        bool? ret = view.InvokeCommand (Command.Select);
+        Assert.True (ret);
+        Assert.True (SelectingInvoked);
+
+        return;
+
+        void ViewOnSelect (object sender, CommandEventArgs e)
+        {
+            SelectingInvoked = true;
+            e.Cancel = true;
+        }
+    }
+
+    [Fact]
+    public void Select_Command_Invokes_Selecting_Event ()
+    {
+        var view = new View ();
+        var selecting = false;
+
+        view.Selecting += ViewOnSelecting;
+
+        view.InvokeCommand (Command.Select);
+        Assert.True (selecting);
+
+        return;
+
+        void ViewOnSelecting (object sender, CommandEventArgs e) { selecting = true; }
+    }
+
+    [Fact]
+    public void MouseClick_Invokes_Select_Command ()
+    {
+        var view = new ViewEventTester ();
+        view.NewMouseEvent (new () { Flags = MouseFlags.Button1Clicked, Position = Point.Empty, View = view });
+
+        Assert.Equal (1, view.OnSelectingCount);
+    }
+
+    #endregion OnSelect/Select tests
+
+    #region OnHotKey/HotKey tests
+
+    [Fact]
+    public void HotKey_Command_SetsFocus ()
+    {
+        var view = new View ();
+
+        view.CanFocus = true;
+        Assert.False (view.HasFocus);
+        view.InvokeCommand (Command.HotKey);
+        Assert.True (view.HasFocus);
+    }
+
+    #endregion OnHotKey/HotKey tests
+
+    public class ViewEventTester : View
+    {
+        public ViewEventTester ()
+        {
+            CanFocus = true;
+
+            Accepting += (s, a) =>
+                      {
+                          a.Cancel = HandleAccepted;
+                          AcceptedCount++;
+                      };
+
+            HandlingHotKey += (s, a) =>
+                             {
+                                 a.Cancel = HandleHandlingHotKey;
+                                 HandlingHotKeyCount++;
+                             };
+
+
+            Selecting += (s, a) =>
+                             {
+                                 a.Cancel = HandleSelecting;
+                                 SelectingCount++;
+                             };
+        }
+
+        public int OnAcceptedCount { get; set; }
+        public int AcceptedCount { get; set; }
+        public bool HandleOnAccepted { get; set; }
+
+        /// <inheritdoc />
+        protected override bool OnAccepting (CommandEventArgs args)
+        {
+            OnAcceptedCount++;
+
+            return HandleOnAccepted;
+        }
+
+        public bool HandleAccepted { get; set; }
+
+        public int OnHandlingHotKeyCount { get; set; }
+        public int HandlingHotKeyCount { get; set; }
+        public bool HandleOnHandlingHotKey { get; set; }
+
+        /// <inheritdoc />
+        protected override bool OnHandlingHotKey (CommandEventArgs args)
+        {
+            OnHandlingHotKeyCount++;
+
+            return HandleOnHandlingHotKey;
+        }
+
+        public bool HandleHandlingHotKey { get; set; }
+
+
+        public int OnSelectingCount { get; set; }
+        public int SelectingCount { get; set; }
+        public bool HandleOnSelecting { get; set; }
+
+        /// <inheritdoc />
+        protected override bool OnSelecting (CommandEventArgs args)
+        {
+            OnSelectingCount++;
+
+            return HandleOnSelecting;
+        }
+
+        public bool HandleSelecting { get; set; }
+
+    }
+}

UnitTests/View/ViewTests.cs

@@ -160,7 +160,7 @@ public class ViewTests (ITestOutputHelper output)
         if (label)
         {
             Assert.False (v.CanFocus);
-            Assert.Equal (new  (0, 0, text.Length, 1), v.Frame);
+            Assert.Equal (new (0, 0, text.Length, 1), v.Frame);
         }
         else
         {
@@ -469,7 +469,7 @@ At 0,0
             X = 0, // don't overcomplicate unit tests
             Y = 1,
             Height = Dim.Auto (DimAutoStyle.Text),
-            Width = Dim.Auto(DimAutoStyle.Text),
+            Width = Dim.Auto (DimAutoStyle.Text),
             Text = "Press me!"
         };
 
@@ -783,7 +783,7 @@ At 0,0
         r.Dispose ();
 
         // Empty Rect
-        r = new() { Frame = Rectangle.Empty };
+        r = new () { Frame = Rectangle.Empty };
         Assert.NotNull (r);
         Assert.Equal ($"View(){r.Viewport}", r.ToString ());
         Assert.False (r.CanFocus);
@@ -807,7 +807,7 @@ At 0,0
         r.Dispose ();
 
         // Rect with values
-        r = new() { Frame = new (1, 2, 3, 4) };
+        r = new () { Frame = new (1, 2, 3, 4) };
         Assert.NotNull (r);
         Assert.Equal ($"View(){r.Frame}", r.ToString ());
         Assert.False (r.CanFocus);
@@ -831,7 +831,7 @@ At 0,0
         r.Dispose ();
 
         // Initializes a view with a vertical direction
-        r = new()
+        r = new ()
         {
             Text = "Vertical View",
             TextDirection = TextDirection.TopBottom_LeftRight,
@@ -870,11 +870,11 @@ At 0,0
     {
         var r = new View ();
 
-        Assert.False (r.OnKeyDown (new() { KeyCode = KeyCode.Null }));
+        Assert.False (r.OnKeyDown (new () { KeyCode = KeyCode.Null }));
 
         //Assert.False (r.OnKeyDown (new KeyEventArgs () { Key = Key.Unknown }));
-        Assert.False (r.OnKeyUp (new() { KeyCode = KeyCode.Null }));
-        Assert.False (r.NewMouseEvent (new() { Flags = MouseFlags.AllEvents }));
+        Assert.False (r.OnKeyUp (new () { KeyCode = KeyCode.Null }));
+        Assert.False (r.NewMouseEvent (new () { Flags = MouseFlags.AllEvents }));
 
         r.Dispose ();
 
@@ -960,7 +960,7 @@ At 0,0
         view.Dispose ();
 
         // Object Initializer
-        view = new() { X = 1, Y = 2, Text = "" };
+        view = new () { X = 1, Y = 2, Text = "" };
         Assert.Equal (1, view.X);
         Assert.Equal (2, view.Y);
         Assert.Equal (0, view.Width);
@@ -975,7 +975,7 @@ At 0,0
         view.Y = 2;
         view.Width = 3;
         view.Height = 4;
-        super = new() { Frame = new (0, 0, 10, 10) };
+        super = new () { Frame = new (0, 0, 10, 10) };
         super.Add (view);
         super.BeginInit ();
         super.EndInit ();
@@ -1153,69 +1153,4 @@ At 0,0
             return true;
         }
     }
-
-    // OnAccept/Accept tests
-    [Fact]
-    public void OnAccept_Fires_Accept ()
-    {
-        var view = new View ();
-        var accepted = false;
-
-        view.Accept += ViewOnAccept;
-
-        view.InvokeCommand (Command.Accept);
-        Assert.True (accepted);
-
-        return;
-
-        void ViewOnAccept (object sender, HandledEventArgs e) { accepted = true; }
-    }
-
-    [Fact]
-    public void Accept_Cancel_Event_OnAccept_Returns_True ()
-    {
-        var view = new View ();
-        var acceptInvoked = false;
-
-        view.Accept += ViewOnAccept;
-
-        bool? ret = view.InvokeCommand (Command.Accept);
-        Assert.True (ret);
-        Assert.True (acceptInvoked);
-
-        return;
-
-        void ViewOnAccept (object sender, HandledEventArgs e)
-        {
-            acceptInvoked = true;
-            e.Handled = true;
-        }
-    }
-
-    [Fact]
-    public void Accept_Command_Invokes_Accept_Event ()
-    {
-        var view = new View ();
-        var accepted = false;
-
-        view.Accept += ViewOnAccept;
-
-        view.InvokeCommand (Command.Accept);
-        Assert.True (accepted);
-
-        return;
-
-        void ViewOnAccept (object sender, HandledEventArgs e) { accepted = true; }
-    }
-
-    [Fact]
-    public void HotKey_Command_SetsFocus ()
-    {
-        var view = new View ();
-
-        view.CanFocus = true;
-        Assert.False (view.HasFocus);
-        view.InvokeCommand (Command.HotKey);
-        Assert.True (view.HasFocus);
-    }
 }