Fix typos

UnitTests/Application/ApplicationTests.cs

@@ -1,5 +1,4 @@
-using Microsoft.VisualBasic;
-using Xunit.Abstractions;
+using Xunit.Abstractions;
 
 // Alias Console to MockConsole so we don't accidentally use Console
 
@@ -7,8 +6,6 @@ namespace Terminal.Gui.ApplicationTests;
 
 public class ApplicationTests
 {
-    private readonly ITestOutputHelper _output;
-
     public ApplicationTests (ITestOutputHelper output)
     {
         _output = output;
@@ -20,6 +17,127 @@ public class ApplicationTests
 #endif
     }
 
+    private readonly ITestOutputHelper _output;
+
+    private object _timeoutLock;
+
+    [Fact]
+    public void AddTimeout_Fires ()
+    {
+        Assert.Null (_timeoutLock);
+        _timeoutLock = new ();
+
+        uint timeoutTime = 250;
+        var initialized = false;
+        var iteration = 0;
+        var shutdown = false;
+        object timeout = null;
+        var timeoutCount = 0;
+
+        Application.InitializedChanged += OnApplicationOnInitializedChanged;
+
+        Application.Init (new FakeDriver ());
+        Assert.True (initialized);
+        Assert.False (shutdown);
+
+        _output.WriteLine ("Application.Run<Toplevel> ().Dispose ()..");
+        Application.Run<Toplevel> ().Dispose ();
+        _output.WriteLine ("Back from Application.Run<Toplevel> ().Dispose ()");
+
+        Assert.True (initialized);
+        Assert.False (shutdown);
+
+        Assert.Equal (1, timeoutCount);
+        Application.Shutdown ();
+
+        Application.InitializedChanged -= OnApplicationOnInitializedChanged;
+
+        lock (_timeoutLock)
+        {
+            if (timeout is { })
+            {
+                Application.RemoveTimeout (timeout);
+                timeout = null;
+            }
+        }
+
+        Assert.True (initialized);
+        Assert.True (shutdown);
+
+#if DEBUG_IDISPOSABLE
+        Assert.Empty (Responder.Instances);
+#endif
+        lock (_timeoutLock)
+        {
+            _timeoutLock = null;
+        }
+
+        return;
+
+        void OnApplicationOnInitializedChanged (object s, EventArgs<bool> a)
+        {
+            if (a.CurrentValue)
+            {
+                Application.Iteration += OnApplicationOnIteration;
+                initialized = true;
+
+                lock (_timeoutLock)
+                {
+                    _output.WriteLine ($"Setting timeout for {timeoutTime}ms");
+                    timeout = Application.AddTimeout (TimeSpan.FromMilliseconds (timeoutTime), TimeoutCallback);
+                }
+            }
+            else
+            {
+                Application.Iteration -= OnApplicationOnIteration;
+                shutdown = true;
+            }
+        }
+
+        bool TimeoutCallback ()
+        {
+            lock (_timeoutLock)
+            {
+                _output.WriteLine ($"TimeoutCallback. Count: {++timeoutCount}. Application Iteration: {iteration}");
+
+                if (timeout is { })
+                {
+                    _output.WriteLine ("  Nulling timeout.");
+                    timeout = null;
+                }
+            }
+
+            // False means "don't re-do timer and remove it"
+            return false;
+        }
+
+        void OnApplicationOnIteration (object s, IterationEventArgs a)
+        {
+            lock (_timeoutLock)
+            {
+                if (timeoutCount > 0)
+                {
+                    _output.WriteLine ($"Iteration #{iteration} - Timeout fired. Calling Application.RequestStop.");
+                    Application.RequestStop ();
+
+                    return;
+                }
+            }
+
+            iteration++;
+
+            // Simulate a delay
+            Thread.Sleep ((int)timeoutTime / 10);
+
+            // Worst case scenario - something went wrong
+            if (Application.IsInitialized && iteration > 25)
+            {
+                _output.WriteLine ($"Too many iterations ({iteration}): Calling Application.RequestStop.");
+                Application.RequestStop ();
+            }
+        }
+    }
+
     [Fact]
     public void Begin_Null_Toplevel_Throws ()
     {
@@ -184,15 +302,18 @@ public class ApplicationTests
             Assert.Null (Application.Driver);
             Assert.Null (Application.MainLoop);
             Assert.False (Application.EndAfterFirstIteration);
-            Assert.Equal (Key.Empty, Application.AlternateBackwardKey);
-            Assert.Equal (Key.Empty, Application.AlternateForwardKey);
-            Assert.Equal (Key.Empty, Application.QuitKey);
+            Assert.Equal (Key.Tab.WithShift, Application.PrevTabKey);
+            Assert.Equal (Key.Tab, Application.NextTabKey);
+            Assert.Equal (Key.F6.WithShift, Application.PrevTabGroupKey);
+            Assert.Equal (Key.F6, Application.NextTabGroupKey);
+            Assert.Equal (Key.Esc, Application.QuitKey);
             Assert.Null (ApplicationOverlapped.OverlappedChildren);
             Assert.Null (ApplicationOverlapped.OverlappedTop);
 
             // Internal properties
             Assert.False (Application.IsInitialized);
             Assert.Equal (Application.GetSupportedCultures (), Application.SupportedCultures);
+            Assert.Equal (Application.GetAvailableCulturesFromEmbeddedResources (), Application.SupportedCultures);
             Assert.False (Application._forceFakeConsole);
             Assert.Equal (-1, Application.MainThreadId);
             Assert.Empty (Application.TopLevels);
@@ -201,7 +322,8 @@ public class ApplicationTests
             // Keyboard
             Assert.Empty (Application.GetViewKeyBindings ());
 
-            Assert.Null (ApplicationNavigation.Focused);
+            // Navigation
+            Assert.Null (Application.Navigation);
 
             // Events - Can't check
             //Assert.Null (Application.NotifyNewRunState);
@@ -232,10 +354,10 @@ public class ApplicationTests
 
         //Application.ForceDriver = "driver";
         Application.EndAfterFirstIteration = true;
-        Application.AlternateBackwardKey = Key.A;
-        Application.AlternateForwardKey = Key.B;
+        Application.PrevTabGroupKey = Key.A;
+        Application.NextTabGroupKey = Key.B;
         Application.QuitKey = Key.C;
-        Application.KeyBindings.Add (Key.A, KeyBindingScope.Application, Command.Cancel);
+        Application.KeyBindings.Add (Key.D, KeyBindingScope.Application, Command.Cancel);
 
         //ApplicationOverlapped.OverlappedChildren = new List<View> ();
         //ApplicationOverlapped.OverlappedTop = 
@@ -243,6 +365,8 @@ public class ApplicationTests
 
         //Application.WantContinuousButtonPressedView = new View ();
 
+        Application.Navigation = new ();
+
         Application.ResetState ();
         CheckReset ();
 
@@ -280,8 +404,8 @@ public class ApplicationTests
     [InlineData (typeof (CursesDriver))]
     public void Init_Shutdown_Fire_InitializedChanged (Type driverType)
     {
-        bool initialized = false;
-        bool shutdown = false;
+        var initialized = false;
+        var shutdown = false;
 
         Application.InitializedChanged += OnApplicationOnInitializedChanged;
 
@@ -310,34 +434,6 @@ public class ApplicationTests
         }
     }
 
-
-    [Fact]
-    public void Run_Iteration_Fires ()
-    {
-        int iteration = 0;
-
-        Application.Init (new FakeDriver ());
-
-        Application.Iteration += Application_Iteration;
-        Application.Run<Toplevel> ().Dispose ();
-
-        Assert.Equal (1, iteration);
-        Application.Shutdown ();
-
-        return;
-
-        void Application_Iteration (object sender, IterationEventArgs e)
-        {
-            if (iteration > 0)
-            {
-                Assert.Fail ();
-            }
-            iteration++;
-            Application.RequestStop ();
-        }
-    }
-
-
     [Fact]
     public void Init_Unbalanced_Throws ()
     {
@@ -444,6 +540,33 @@ public class ApplicationTests
         Application.Shutdown ();
     }
 
+    [Fact]
+    public void Run_Iteration_Fires ()
+    {
+        var iteration = 0;
+
+        Application.Init (new FakeDriver ());
+
+        Application.Iteration += Application_Iteration;
+        Application.Run<Toplevel> ().Dispose ();
+
+        Assert.Equal (1, iteration);
+        Application.Shutdown ();
+
+        return;
+
+        void Application_Iteration (object sender, IterationEventArgs e)
+        {
+            if (iteration > 0)
+            {
+                Assert.Fail ();
+            }
+
+            iteration++;
+            Application.RequestStop ();
+        }
+    }
+
     [Fact]
     [AutoInitShutdown]
     public void SetCurrentAsTop_Run_A_Not_Modal_Toplevel_Make_It_The_Current_Application_Top ()
@@ -894,15 +1017,15 @@ public class ApplicationTests
         RunState rs = Application.Begin (w);
 
         // Don't use visuals to test as style of border can change over time.
-        Assert.Equal (new Point (0, 0), w.Frame.Location);
+        Assert.Equal (new (0, 0), w.Frame.Location);
 
         Application.OnMouseEvent (new () { Flags = MouseFlags.Button1Pressed });
         Assert.Equal (w.Border, Application.MouseGrabView);
-        Assert.Equal (new Point (0, 0), w.Frame.Location);
+        Assert.Equal (new (0, 0), w.Frame.Location);
 
         // Move down and to the right.
         Application.OnMouseEvent (new () { Position = new (1, 1), Flags = MouseFlags.Button1Pressed | MouseFlags.ReportMousePosition });
-        Assert.Equal (new Point (1, 1), w.Frame.Location);
+        Assert.Equal (new (1, 1), w.Frame.Location);
 
         Application.End (rs);
         w.Dispose ();
@@ -1037,6 +1160,7 @@ public class ApplicationTests
         Assert.Throws<InvalidOperationException> (() => Application.Run (new Toplevel ()));
 
         Application.Init (driver);
+
         Application.Iteration += (s, e) =>
                                  {
                                      Assert.NotNull (Application.Top);
@@ -1096,123 +1220,4 @@ public class ApplicationTests
     }
 
     #endregion
-
-
-    private object _timeoutLock;
-
-    [Fact]
-    public void AddTimeout_Fires ()
-    {
-        Assert.Null (_timeoutLock);
-        _timeoutLock = new object ();
-
-        uint timeoutTime = 250;
-        bool initialized = false;
-        int iteration = 0;
-        bool shutdown = false;
-        object timeout = null;
-        int timeoutCount = 0;
-
-        Application.InitializedChanged += OnApplicationOnInitializedChanged;
-
-        Application.Init (new FakeDriver ());
-        Assert.True (initialized);
-        Assert.False (shutdown);
-
-        _output.WriteLine ("Application.Run<Toplevel> ().Dispose ()..");
-        Application.Run<Toplevel> ().Dispose ();
-        _output.WriteLine ("Back from Application.Run<Toplevel> ().Dispose ()");
-
-        Assert.True (initialized);
-        Assert.False (shutdown);
-
-        Assert.Equal (1, timeoutCount);
-        Application.Shutdown ();
-
-        Application.InitializedChanged -= OnApplicationOnInitializedChanged;
-
-        lock (_timeoutLock)
-        {
-            if (timeout is { })
-            {
-                Application.RemoveTimeout (timeout);
-                timeout = null;
-            }
-        }
-
-        Assert.True (initialized);
-        Assert.True (shutdown);
-
-#if DEBUG_IDISPOSABLE
-        Assert.Empty (Responder.Instances);
-#endif
-        lock (_timeoutLock)
-        {
-            _timeoutLock = null;
-        }
-
-        return;
-
-        void OnApplicationOnInitializedChanged (object s, EventArgs<bool> a)
-        {
-            if (a.CurrentValue)
-            {
-                Application.Iteration += OnApplicationOnIteration;
-                initialized = true;
-
-                lock (_timeoutLock)
-                {
-                    _output.WriteLine ($"Setting timeout for {timeoutTime}ms");
-                    timeout = Application.AddTimeout (TimeSpan.FromMilliseconds (timeoutTime), TimeoutCallback);
-                }
-
-            }
-            else
-            {
-                Application.Iteration -= OnApplicationOnIteration;
-                shutdown = true;
-            }
-        }
-
-        bool TimeoutCallback ()
-        {
-            lock (_timeoutLock)
-            {
-                _output.WriteLine ($"TimeoutCallback. Count: {++timeoutCount}. Application Iteration: {iteration}");
-                if (timeout is { })
-                {
-                    _output.WriteLine ($"  Nulling timeout.");
-                    timeout = null;
-                }
-            }
-
-            // False means "don't re-do timer and remove it"
-            return false;
-        }
-
-        void OnApplicationOnIteration (object s, IterationEventArgs a)
-        {
-            lock (_timeoutLock)
-            {
-                if (timeoutCount > 0)
-                {
-                    _output.WriteLine ($"Iteration #{iteration} - Timeout fired. Calling Application.RequestStop.");
-                    Application.RequestStop ();
-
-                    return;
-                }
-            }
-            iteration++;
-
-            // Simulate a delay
-            Thread.Sleep ((int)timeoutTime / 10);
-
-            // Worst case scenario - something went wrong
-            if (Application.IsInitialized && iteration > 25)
-            {
-                _output.WriteLine ($"Too many iterations ({iteration}): Calling Application.RequestStop.");
-                Application.RequestStop ();
-            }
-        }
-    }
 }

UnitTests/Application/KeyboardTests.cs

@@ -65,7 +65,7 @@ public class KeyboardTests
     {
         Application.ResetState (true);
         // Before Init
-        Assert.Equal (Key.Empty, Application.QuitKey);
+        Assert.Equal (Key.Esc, Application.QuitKey);
 
         Application.Init (new FakeDriver ());
         // After Init
@@ -178,7 +178,7 @@ public class KeyboardTests
     }
 
     [Fact (Skip = "Replace when new key statics are added.")]
-    public void AlternateForwardKey_AlternateBackwardKey_Tests ()
+    public void NextTabGroupKey_PrevTabGroupKey_Tests ()
     {
         Application.Init (new FakeDriver ());
 
@@ -200,45 +200,27 @@ public class KeyboardTests
                                      Assert.True (v1.HasFocus);
 
                                      // Using default keys.
-                                     Application.OnKeyDown (Key.Tab.WithCtrl);
+                                     Application.OnKeyDown (Key.F6);
                                      Assert.True (v2.HasFocus);
-                                     Application.OnKeyDown (Key.Tab.WithCtrl);
+                                     Application.OnKeyDown (Key.F6);
                                      Assert.True (v3.HasFocus);
-                                     Application.OnKeyDown (Key.Tab.WithCtrl);
+                                     Application.OnKeyDown (Key.F6);
                                      Assert.True (v4.HasFocus);
-                                     Application.OnKeyDown (Key.Tab.WithCtrl);
+                                     Application.OnKeyDown (Key.F6);
                                      Assert.True (v1.HasFocus);
 
-                                     Application.OnKeyDown (Key.Tab.WithShift.WithCtrl);
+                                     Application.OnKeyDown (Key.F6.WithShift);
                                      Assert.True (v4.HasFocus);
-                                     Application.OnKeyDown (Key.Tab.WithShift.WithCtrl);
+                                     Application.OnKeyDown (Key.F6.WithShift);
                                      Assert.True (v3.HasFocus);
-                                     Application.OnKeyDown (Key.Tab.WithShift.WithCtrl);
+                                     Application.OnKeyDown (Key.F6.WithShift);
                                      Assert.True (v2.HasFocus);
-                                     Application.OnKeyDown (Key.Tab.WithShift.WithCtrl);
+                                     Application.OnKeyDown (Key.F6.WithShift);
                                      Assert.True (v1.HasFocus);
-
-                                     Application.OnKeyDown (Key.PageDown.WithCtrl);
-                                     Assert.True (v2.HasFocus);
-                                     Application.OnKeyDown (Key.PageDown.WithCtrl);
-                                     Assert.True (v3.HasFocus);
-                                     Application.OnKeyDown (Key.PageDown.WithCtrl);
-                                     Assert.True (v4.HasFocus);
-                                     Application.OnKeyDown (Key.PageDown.WithCtrl);
-                                     Assert.True (v1.HasFocus);
-
-                                     Application.OnKeyDown (Key.PageUp.WithCtrl);
-                                     Assert.True (v4.HasFocus);
-                                     Application.OnKeyDown (Key.PageUp.WithCtrl);
-                                     Assert.True (v3.HasFocus);
-                                     Application.OnKeyDown (Key.PageUp.WithCtrl);
-                                     Assert.True (v2.HasFocus);
-                                     Application.OnKeyDown (Key.PageUp.WithCtrl);
-                                     Assert.True (v1.HasFocus);
-
-                                     // Using another's alternate keys.
-                                     Application.AlternateForwardKey = Key.F7;
-                                     Application.AlternateBackwardKey = Key.F6;
+                                     
+                                     // Using alternate keys.
+                                     Application.NextTabGroupKey = Key.F7;
+                                     Application.PrevTabGroupKey = Key.F8;
 
                                      Application.OnKeyDown (Key.F7);
                                      Assert.True (v2.HasFocus);
@@ -249,13 +231,13 @@ public class KeyboardTests
                                      Application.OnKeyDown (Key.F7);
                                      Assert.True (v1.HasFocus);
 
-                                     Application.OnKeyDown (Key.F6);
+                                     Application.OnKeyDown (Key.F8);
                                      Assert.True (v4.HasFocus);
-                                     Application.OnKeyDown (Key.F6);
+                                     Application.OnKeyDown (Key.F8);
                                      Assert.True (v3.HasFocus);
-                                     Application.OnKeyDown (Key.F6);
+                                     Application.OnKeyDown (Key.F8);
                                      Assert.True (v2.HasFocus);
-                                     Application.OnKeyDown (Key.F6);
+                                     Application.OnKeyDown (Key.F8);
                                      Assert.True (v1.HasFocus);
 
                                      Application.RequestStop ();
@@ -264,12 +246,12 @@ public class KeyboardTests
         Application.Run (top);
 
         // Replacing the defaults keys to avoid errors on others unit tests that are using it.
-        Application.AlternateForwardKey = Key.PageDown.WithCtrl;
-        Application.AlternateBackwardKey = Key.PageUp.WithCtrl;
+        Application.NextTabGroupKey = Key.PageDown.WithCtrl;
+        Application.PrevTabGroupKey = Key.PageUp.WithCtrl;
         Application.QuitKey = Key.Q.WithCtrl;
 
-        Assert.Equal (KeyCode.PageDown | KeyCode.CtrlMask, Application.AlternateForwardKey.KeyCode);
-        Assert.Equal (KeyCode.PageUp | KeyCode.CtrlMask, Application.AlternateBackwardKey.KeyCode);
+        Assert.Equal (KeyCode.PageDown | KeyCode.CtrlMask, Application.NextTabGroupKey.KeyCode);
+        Assert.Equal (KeyCode.PageUp | KeyCode.CtrlMask, Application.PrevTabGroupKey.KeyCode);
         Assert.Equal (KeyCode.Q | KeyCode.CtrlMask, Application.QuitKey.KeyCode);
 
         top.Dispose ();
@@ -321,14 +303,14 @@ public class KeyboardTests
         Assert.True (win2.HasFocus);
         Assert.Equal ("win2", ((Window)top.Subviews [^1]).Title);
 
-        Application.OnKeyDown (Key.Tab.WithCtrl);
+        Application.OnKeyDown (Key.F6);
         Assert.True (win2.CanFocus);
         Assert.False (win.HasFocus);
         Assert.True (win2.CanFocus);
         Assert.True (win2.HasFocus);
         Assert.Equal ("win2", ((Window)top.Subviews [^1]).Title);
 
-        Application.OnKeyDown (Key.Tab.WithCtrl);
+        Application.OnKeyDown (Key.F6);
         Assert.False (win.CanFocus);
         Assert.False (win.HasFocus);
         Assert.True (win2.CanFocus);
@@ -374,14 +356,14 @@ public class KeyboardTests
         Assert.False (win2.HasFocus);
         Assert.Equal ("win", ((Window)top.Subviews [^1]).Title);
 
-        Application.OnKeyDown (Key.Tab.WithCtrl);
+        Application.OnKeyDown (Key.F6);
         Assert.True (win.CanFocus);
         Assert.False (win.HasFocus);
         Assert.True (win2.CanFocus);
         Assert.True (win2.HasFocus);
         Assert.Equal ("win2", ((Window)top.Subviews [^1]).Title);
 
-        Application.OnKeyDown (Key.Tab.WithCtrl);
+        Application.OnKeyDown (Key.F6);
         Assert.True (win.CanFocus);
         Assert.True (win.HasFocus);
         Assert.True (win2.CanFocus);