gui-cs.Terminal.Gui/UnitTests/Views/OverlappedTests.cs

using System.Threading;
using Xunit.Abstractions;

namespace Terminal.Gui.ViewsTests;

public class OverlappedTests
{
    private readonly ITestOutputHelper _output;

    public OverlappedTests (ITestOutputHelper output)
    {
        _output = output;
#if DEBUG_IDISPOSABLE
        Responder.Instances.Clear ();
        RunState.Instances.Clear ();
#endif
    }

    [Fact]
    [AutoInitShutdown]
    public void AllChildClosed_Event_Test ()
    {
        var overlapped = new Overlapped ();
        var c1 = new Toplevel ();
        var c2 = new Window ();
        var c3 = new Window ();

        // OverlappedChild = c1, c2, c3
        var iterations = 3;

        overlapped.Ready += (s, e) =>
                            {
                                Assert.Empty (Application.OverlappedChildren);
                                Application.Run (c1);
                            };

        c1.Ready += (s, e) =>
                    {
                        Assert.Single (Application.OverlappedChildren);
                        Application.Run (c2);
                    };

        c2.Ready += (s, e) =>
                    {
                        Assert.Equal (2, Application.OverlappedChildren.Count);
                        Application.Run (c3);
                    };

        c3.Ready += (s, e) =>
                    {
                        Assert.Equal (3, Application.OverlappedChildren.Count);
                        c3.RequestStop ();
                        c2.RequestStop ();
                        c1.RequestStop ();
                    };

        // Now this will close the OverlappedContainer when all OverlappedChildren was closed
        overlapped.AllChildClosed += (s, e) => { overlapped.RequestStop (); };

        Application.Iteration += (s, a) =>
                                 {
                                     if (iterations == 3)
                                     {
                                         // The Current still is c3 because Current.Running is false.
                                         Assert.True (Application.Current == c3);
                                         Assert.False (Application.Current.Running);

                                         // But the Children order were reorder by Running = false
                                         Assert.True (Application.OverlappedChildren [0] == c3);
                                         Assert.True (Application.OverlappedChildren [1] == c2);
                                         Assert.True (Application.OverlappedChildren [^1] == c1);
                                     }
                                     else if (iterations == 2)
                                     {
                                         // The Current is c2 and Current.Running is false.
                                         Assert.True (Application.Current == c2);
                                         Assert.False (Application.Current.Running);
                                         Assert.True (Application.OverlappedChildren [0] == c2);
                                         Assert.True (Application.OverlappedChildren [^1] == c1);
                                     }
                                     else if (iterations == 1)
                                     {
                                         // The Current is c1 and Current.Running is false.
                                         Assert.True (Application.Current == c1);
                                         Assert.False (Application.Current.Running);
                                         Assert.True (Application.OverlappedChildren [^1] == c1);
                                     }
                                     else
                                     {
                                         // The Current is overlapped.
                                         Assert.True (Application.Current == overlapped);
                                         Assert.False (Application.Current.Running);
                                         Assert.Empty (Application.OverlappedChildren);
                                     }

                                     iterations--;
                                 };

        Application.Run (overlapped);

        Assert.Empty (Application.OverlappedChildren);
        Assert.NotNull (Application.OverlappedTop);
        Assert.NotNull (Application.Top);
        overlapped.Dispose ();
    }

    [Fact]
    [AutoInitShutdown]
    public void Application_RequestStop_With_Params_On_A_Not_OverlappedContainer_Always_Use_Application_Current ()
    {
        var top1 = new Toplevel ();
        var top2 = new Toplevel ();
        var top3 = new Window ();
        var top4 = new Window ();
        var d = new Dialog ();

        // top1, top2, top3, d1 = 4
        var iterations = 4;

        top1.Ready += (s, e) =>
                      {
                          Assert.Null (Application.OverlappedChildren);
                          Application.Run (top2);
                      };

        top2.Ready += (s, e) =>
                      {
                          Assert.Null (Application.OverlappedChildren);
                          Application.Run (top3);
                      };

        top3.Ready += (s, e) =>
                      {
                          Assert.Null (Application.OverlappedChildren);
                          Application.Run (top4);
                      };

        top4.Ready += (s, e) =>
                      {
                          Assert.Null (Application.OverlappedChildren);
                          Application.Run (d);
                      };

        d.Ready += (s, e) =>
                   {
                       Assert.Null (Application.OverlappedChildren);

                       // This will close the d because on a not OverlappedContainer the Application.Current it always used.
                       Application.RequestStop (top1);
                       Assert.True (Application.Current == d);
                   };

        d.Closed += (s, e) => Application.RequestStop (top1);

        Application.Iteration += (s, a) =>
                                 {
                                     Assert.Null (Application.OverlappedChildren);

                                     if (iterations == 4)
                                     {
                                         Assert.True (Application.Current == d);
                                     }
                                     else if (iterations == 3)
                                     {
                                         Assert.True (Application.Current == top4);
                                     }
                                     else if (iterations == 2)
                                     {
                                         Assert.True (Application.Current == top3);
                                     }
                                     else if (iterations == 1)
                                     {
                                         Assert.True (Application.Current == top2);
                                     }
                                     else
                                     {
                                         Assert.True (Application.Current == top1);
                                     }

                                     Application.RequestStop (top1);
                                     iterations--;
                                 };

        Application.Run (top1);

        Assert.Null (Application.OverlappedChildren);
        top1.Dispose ();
    }

    [Fact]
    [TestRespondersDisposed]
    public void Dispose_Toplevel_IsOverlappedContainer_False_With_Begin_End ()
    {
        Application.Init (new FakeDriver ());

        var top = new Toplevel ();
        RunState rs = Application.Begin (top);

        Application.End (rs);
        top.Dispose ();
        Application.Shutdown ();

#if DEBUG_IDISPOSABLE
        Assert.Empty (Responder.Instances);
#endif
    }

    [Fact]
    [TestRespondersDisposed]
    public void Dispose_Toplevel_IsOverlappedContainer_True_With_Begin ()
    {
        Application.Init (new FakeDriver ());

        var overlapped = new Toplevel { IsOverlappedContainer = true };
        RunState rs = Application.Begin (overlapped);
        Application.End (rs);
        overlapped.Dispose ();
        Application.Shutdown ();
    }

    [Fact]
    [AutoInitShutdown]
    public void IsOverlappedChild_Testing ()
    {
        var overlapped = new Overlapped ();
        var c1 = new Toplevel ();
        var c2 = new Window ();
        var c3 = new Window ();
        var d = new Dialog ();

        Application.Iteration += (s, a) =>
                                 {
                                     Assert.False (overlapped.IsOverlapped);
                                     Assert.True (c1.IsOverlapped);
                                     Assert.True (c2.IsOverlapped);
                                     Assert.True (c3.IsOverlapped);
                                     Assert.False (d.IsOverlapped);

                                     overlapped.RequestStop ();
                                 };

        Application.Run (overlapped);
        overlapped.Dispose ();
    }

    [Fact]
    [AutoInitShutdown]
    public void
        Modal_Toplevel_Can_Open_Another_Modal_Toplevel_But_RequestStop_To_The_Caller_Also_Sets_Current_Running_To_False_Too ()
    {
        var overlapped = new Overlapped ();
        var c1 = new Toplevel ();
        var c2 = new Window ();
        var c3 = new Window ();
        var d1 = new Dialog ();
        var d2 = new Dialog ();

        // OverlappedChild = c1, c2, c3 = 3
        // d1, d2 = 2
        var iterations = 5;

        overlapped.Ready += (s, e) =>
                            {
                                Assert.Empty (Application.OverlappedChildren);
                                Application.Run (c1);
                            };

        c1.Ready += (s, e) =>
                    {
                        Assert.Single (Application.OverlappedChildren);
                        Application.Run (c2);
                    };

        c2.Ready += (s, e) =>
                    {
                        Assert.Equal (2, Application.OverlappedChildren.Count);
                        Application.Run (c3);
                    };

        c3.Ready += (s, e) =>
                    {
                        Assert.Equal (3, Application.OverlappedChildren.Count);
                        Application.Run (d1);
                    };

        d1.Ready += (s, e) =>
                    {
                        Assert.Equal (3, Application.OverlappedChildren.Count);
                        Application.Run (d2);
                    };

        d2.Ready += (s, e) =>
                    {
                        Assert.Equal (3, Application.OverlappedChildren.Count);
                        Assert.True (Application.Current == d2);
                        Assert.True (Application.Current.Running);

                        // Trying to close the Dialog1
                        d1.RequestStop ();
                    };

        // Now this will close the OverlappedContainer propagating through the OverlappedChildren.
        d1.Closed += (s, e) =>
                     {
                         Assert.True (Application.Current == d1);
                         Assert.False (Application.Current.Running);
                         overlapped.RequestStop ();
                     };

        Application.Iteration += (s, a) =>
                                 {
                                     if (iterations == 5)
                                     {
                                         // The Dialog2 still is the current top and we can't request stop to OverlappedContainer
                                         // because Dialog2 and Dialog1 must be closed first.
                                         // Dialog2 will be closed in this iteration.
                                         Assert.True (Application.Current == d2);
                                         Assert.False (Application.Current.Running);
                                         Assert.False (d1.Running);
                                     }
                                     else if (iterations == 4)
                                     {
                                         // Dialog1 will be closed in this iteration.
                                         Assert.True (Application.Current == d1);
                                         Assert.False (Application.Current.Running);
                                     }
                                     else
                                     {
                                         Assert.Equal (iterations, Application.OverlappedChildren.Count);

                                         for (var i = 0; i < iterations; i++)
                                         {
                                             Assert.Equal ((iterations - i + 1).ToString (), Application.OverlappedChildren [i].Id);
                                         }
                                     }

                                     iterations--;
                                 };

        Application.Run (overlapped);

        Assert.Empty (Application.OverlappedChildren);
        Assert.NotNull (Application.OverlappedTop);
        Assert.NotNull (Application.Top);
        overlapped.Dispose ();
    }

    [Fact]
    [AutoInitShutdown]
    public void
        Modal_Toplevel_Can_Open_Another_Not_Modal_Toplevel_But_RequestStop_To_The_Caller_Also_Sets_Current_Running_To_False_Too ()
    {
        var overlapped = new Overlapped ();
        var c1 = new Toplevel ();
        var c2 = new Window ();
        var c3 = new Window ();
        var d1 = new Dialog ();
        var c4 = new Toplevel ();

        // OverlappedChild = c1, c2, c3, c4 = 4
        // d1 = 1
        var iterations = 5;

        overlapped.Ready += (s, e) =>
                            {
                                Assert.Empty (Application.OverlappedChildren);
                                Application.Run (c1);
                            };

        c1.Ready += (s, e) =>
                    {
                        Assert.Single (Application.OverlappedChildren);
                        Application.Run (c2);
                    };

        c2.Ready += (s, e) =>
                    {
                        Assert.Equal (2, Application.OverlappedChildren.Count);
                        Application.Run (c3);
                    };

        c3.Ready += (s, e) =>
                    {
                        Assert.Equal (3, Application.OverlappedChildren.Count);
                        Application.Run (d1);
                    };

        d1.Ready += (s, e) =>
                    {
                        Assert.Equal (3, Application.OverlappedChildren.Count);
                        Application.Run (c4);
                    };

        c4.Ready += (s, e) =>
                    {
                        Assert.Equal (4, Application.OverlappedChildren.Count);

                        // Trying to close the Dialog1
                        d1.RequestStop ();
                    };

        // Now this will close the OverlappedContainer propagating through the OverlappedChildren.
        d1.Closed += (s, e) => { overlapped.RequestStop (); };

        Application.Iteration += (s, a) =>
                                 {
                                     if (iterations == 5)
                                     {
                                         // The Dialog2 still is the current top and we can't request stop to OverlappedContainer
                                         // because Dialog2 and Dialog1 must be closed first.
                                         // Using request stop here will call the Dialog again without need
                                         Assert.True (Application.Current == d1);
                                         Assert.False (Application.Current.Running);
                                         Assert.True (c4.Running);
                                     }
                                     else
                                     {
                                         Assert.Equal (iterations, Application.OverlappedChildren.Count);

                                         for (var i = 0; i < iterations; i++)
                                         {
                                             Assert.Equal (
                                                           (iterations - i + (iterations == 4 && i == 0 ? 2 : 1)).ToString (),
                                                           Application.OverlappedChildren [i].Id
                                                          );
                                         }
                                     }

                                     iterations--;
                                 };

        Application.Run (overlapped);

        Assert.Empty (Application.OverlappedChildren);
        Assert.NotNull (Application.OverlappedTop);
        Assert.NotNull (Application.Top);
        overlapped.Dispose ();
    }

    [Fact]
    [AutoInitShutdown]
    public void MoveCurrent_Returns_False_If_The_Current_And_Top_Parameter_Are_Both_With_Running_Set_To_False ()
    {
        var overlapped = new Overlapped ();
        var c1 = new Toplevel ();
        var c2 = new Window ();
        var c3 = new Window ();

        // OverlappedChild = c1, c2, c3
        var iterations = 3;

        overlapped.Ready += (s, e) =>
                            {
                                Assert.Empty (Application.OverlappedChildren);
                                Application.Run (c1);
                            };

        c1.Ready += (s, e) =>
                    {
                        Assert.Single (Application.OverlappedChildren);
                        Application.Run (c2);
                    };

        c2.Ready += (s, e) =>
                    {
                        Assert.Equal (2, Application.OverlappedChildren.Count);
                        Application.Run (c3);
                    };

        c3.Ready += (s, e) =>
                    {
                        Assert.Equal (3, Application.OverlappedChildren.Count);
                        c3.RequestStop ();
                        c1.RequestStop ();
                    };

        // Now this will close the OverlappedContainer propagating through the OverlappedChildren.
        c1.Closed += (s, e) => { overlapped.RequestStop (); };

        Application.Iteration += (s, a) =>
                                 {
                                     if (iterations == 3)
                                     {
                                         // The Current still is c3 because Current.Running is false.
                                         Assert.True (Application.Current == c3);
                                         Assert.False (Application.Current.Running);

                                         // But the Children order were reorder by Running = false
                                         Assert.True (Application.OverlappedChildren [0] == c3);
                                         Assert.True (Application.OverlappedChildren [1] == c1);
                                         Assert.True (Application.OverlappedChildren [^1] == c2);
                                     }
                                     else if (iterations == 2)
                                     {
                                         // The Current is c1 and Current.Running is false.
                                         Assert.True (Application.Current == c1);
                                         Assert.False (Application.Current.Running);
                                         Assert.True (Application.OverlappedChildren [0] == c1);
                                         Assert.True (Application.OverlappedChildren [^1] == c2);
                                     }
                                     else if (iterations == 1)
                                     {
                                         // The Current is c2 and Current.Running is false.
                                         Assert.True (Application.Current == c2);
                                         Assert.False (Application.Current.Running);
                                         Assert.True (Application.OverlappedChildren [^1] == c2);
                                     }
                                     else
                                     {
                                         // The Current is overlapped.
                                         Assert.True (Application.Current == overlapped);
                                         Assert.Empty (Application.OverlappedChildren);
                                     }

                                     iterations--;
                                 };

        Application.Run (overlapped);

        Assert.Empty (Application.OverlappedChildren);
        Assert.NotNull (Application.OverlappedTop);
        Assert.NotNull (Application.Top);
        overlapped.Dispose ();
    }

    [Fact]
    public void MoveToOverlappedChild_Throw_NullReferenceException_Passing_Null_Parameter ()
    {
        Assert.Throws<NullReferenceException> (delegate { Application.MoveToOverlappedChild (null); });
    }

    [Fact]
    [AutoInitShutdown]
    public void OverlappedContainer_Open_And_Close_Modal_And_Open_Not_Modal_Toplevels_Randomly ()
    {
        var overlapped = new Overlapped ();
        var logger = new Toplevel ();

        var iterations = 1; // The logger
        var running = true;
        var stageCompleted = true;
        var allStageClosed = false;
        var overlappedRequestStop = false;

        overlapped.Ready += (s, e) =>
                            {
                                Assert.Empty (Application.OverlappedChildren);
                                Application.Run (logger);
                            };

        logger.Ready += (s, e) => Assert.Single (Application.OverlappedChildren);

        Application.Iteration += (s, a) =>
                                 {
                                     if (stageCompleted && running)
                                     {
                                         stageCompleted = false;
                                         var stage = new Window { Modal = true };

                                         stage.Ready += (s, e) =>
                                                        {
                                                            Assert.Equal (iterations, Application.OverlappedChildren.Count);
                                                            stage.RequestStop ();
                                                        };

                                         stage.Closed += (_, _) =>
                                                         {
                                                             if (iterations == 11)
                                                             {
                                                                 allStageClosed = true;
                                                             }

                                                             Assert.Equal (iterations, Application.OverlappedChildren.Count);

                                                             if (running)
                                                             {
                                                                 stageCompleted = true;

                                                                 var rpt = new Window ();

                                                                 rpt.Ready += (s, e) =>
                                                                              {
                                                                                  iterations++;
                                                                                  Assert.Equal (iterations, Application.OverlappedChildren.Count);
                                                                              };

                                                                 Application.Run (rpt);
                                                             }
                                                         };

                                         Application.Run (stage);
                                     }
                                     else if (iterations == 11 && running)
                                     {
                                         running = false;
                                         Assert.Equal (iterations, Application.OverlappedChildren.Count);
                                     }
                                     else if (!overlappedRequestStop && running && !allStageClosed)
                                     {
                                         Assert.Equal (iterations, Application.OverlappedChildren.Count);
                                     }
                                     else if (!overlappedRequestStop && !running && allStageClosed)
                                     {
                                         Assert.Equal (iterations, Application.OverlappedChildren.Count);
                                         overlappedRequestStop = true;
                                         overlapped.RequestStop ();
                                     }
                                     else
                                     {
                                         Assert.Empty (Application.OverlappedChildren);
                                     }
                                 };

        Application.Run (overlapped);

        Assert.Empty (Application.OverlappedChildren);
        Assert.NotNull (Application.OverlappedTop);
        Assert.NotNull (Application.Top);
        overlapped.Dispose ();
    }

    [Fact]
    [AutoInitShutdown]
    public void OverlappedContainer_Throws_If_More_Than_One ()
    {
        var overlapped = new Overlapped ();
        var overlapped2 = new Overlapped ();

        overlapped.Ready += (s, e) =>
                            {
                                Assert.Throws<InvalidOperationException> (() => Application.Run (overlapped2));
                                overlapped.RequestStop ();
                            };

        Application.Run (overlapped);
        overlapped.Dispose ();
    }

    [Fact]
    [AutoInitShutdown]
    public void OverlappedContainer_With_Application_RequestStop_OverlappedTop_With_Params ()
    {
        var overlapped = new Overlapped ();
        var c1 = new Toplevel ();
        var c2 = new Window ();
        var c3 = new Window ();
        var d = new Dialog ();

        // OverlappedChild = c1, c2, c3
        // d1 = 1
        var iterations = 4;

        overlapped.Ready += (s, e) =>
                            {
                                Assert.Empty (Application.OverlappedChildren);
                                Application.Run (c1);
                            };

        c1.Ready += (s, e) =>
                    {
                        Assert.Single (Application.OverlappedChildren);
                        Application.Run (c2);
                    };

        c2.Ready += (s, e) =>
                    {
                        Assert.Equal (2, Application.OverlappedChildren.Count);
                        Application.Run (c3);
                    };

        c3.Ready += (s, e) =>
                    {
                        Assert.Equal (3, Application.OverlappedChildren.Count);
                        Application.Run (d);
                    };

        // Also easy because the Overlapped Container handles all at once
        d.Ready += (s, e) =>
                   {
                       Assert.Equal (3, Application.OverlappedChildren.Count);

                       // This will not close the OverlappedContainer because d is a modal Toplevel
                       Application.RequestStop (overlapped);
                   };

        // Now this will close the OverlappedContainer propagating through the OverlappedChildren.
        d.Closed += (s, e) => Application.RequestStop (overlapped);

        Application.Iteration += (s, a) =>
                                 {
                                     if (iterations == 4)
                                     {
                                         // The Dialog was not closed before and will be closed now.
                                         Assert.True (Application.Current == d);
                                         Assert.False (d.Running);
                                     }
                                     else
                                     {
                                         Assert.Equal (iterations, Application.OverlappedChildren.Count);

                                         for (var i = 0; i < iterations; i++)
                                         {
                                             Assert.Equal ((iterations - i + 1).ToString (), Application.OverlappedChildren [i].Id);
                                         }
                                     }

                                     iterations--;
                                 };

        Application.Run (overlapped);

        Assert.Empty (Application.OverlappedChildren);
        Assert.NotNull (Application.OverlappedTop);
        Assert.NotNull (Application.Top);
        overlapped.Dispose ();
    }

    [Fact]
    [AutoInitShutdown]
    public void OverlappedContainer_With_Application_RequestStop_OverlappedTop_Without_Params ()
    {
        var overlapped = new Overlapped ();
        var c1 = new Toplevel ();
        var c2 = new Window ();
        var c3 = new Window ();
        var d = new Dialog ();

        // OverlappedChild = c1, c2, c3 = 3
        // d1 = 1
        var iterations = 4;

        overlapped.Ready += (s, e) =>
                            {
                                Assert.Empty (Application.OverlappedChildren);
                                Application.Run (c1);
                            };

        c1.Ready += (s, e) =>
                    {
                        Assert.Single (Application.OverlappedChildren);
                        Application.Run (c2);
                    };

        c2.Ready += (s, e) =>
                    {
                        Assert.Equal (2, Application.OverlappedChildren.Count);
                        Application.Run (c3);
                    };

        c3.Ready += (s, e) =>
                    {
                        Assert.Equal (3, Application.OverlappedChildren.Count);
                        Application.Run (d);
                    };

        //More harder because it's sequential.
        d.Ready += (s, e) =>
                   {
                       Assert.Equal (3, Application.OverlappedChildren.Count);

                       // Close the Dialog
                       Application.RequestStop ();
                   };

        // Now this will close the OverlappedContainer propagating through the OverlappedChildren.
        d.Closed += (s, e) => Application.RequestStop (overlapped);

        Application.Iteration += (s, a) =>
                                 {
                                     if (iterations == 4)
                                     {
                                         // The Dialog still is the current top and we can't request stop to OverlappedContainer
                                         // because we are not using parameter calls.
                                         Assert.True (Application.Current == d);
                                         Assert.False (d.Running);
                                     }
                                     else
                                     {
                                         Assert.Equal (iterations, Application.OverlappedChildren.Count);

                                         for (var i = 0; i < iterations; i++)
                                         {
                                             Assert.Equal ((iterations - i + 1).ToString (), Application.OverlappedChildren [i].Id);
                                         }
                                     }

                                     iterations--;
                                 };

        Application.Run (overlapped);

        Assert.Empty (Application.OverlappedChildren);
        Assert.NotNull (Application.OverlappedTop);
        Assert.NotNull (Application.Top);
        overlapped.Dispose ();
    }

    [Fact]
    [AutoInitShutdown]
    public void OverlappedContainer_With_Toplevel_RequestStop_Balanced ()
    {
        var overlapped = new Overlapped ();
        var c1 = new Toplevel ();
        var c2 = new Window ();
        var c3 = new Window ();
        var d = new Dialog ();

        // OverlappedChild = c1, c2, c3
        // d1 = 1
        var iterations = 4;

        overlapped.Ready += (s, e) =>
                            {
                                Assert.Empty (Application.OverlappedChildren);
                                Application.Run (c1);
                            };

        c1.Ready += (s, e) =>
                    {
                        Assert.Single (Application.OverlappedChildren);
                        Application.Run (c2);
                    };

        c2.Ready += (s, e) =>
                    {
                        Assert.Equal (2, Application.OverlappedChildren.Count);
                        Application.Run (c3);
                    };

        c3.Ready += (s, e) =>
                    {
                        Assert.Equal (3, Application.OverlappedChildren.Count);
                        Application.Run (d);
                    };

        // More easy because the Overlapped Container handles all at once
        d.Ready += (s, e) =>
                   {
                       Assert.Equal (3, Application.OverlappedChildren.Count);

                       // This will not close the OverlappedContainer because d is a modal Toplevel and will be closed.
                       overlapped.RequestStop ();
                   };

        // Now this will close the OverlappedContainer propagating through the OverlappedChildren.
        d.Closed += (s, e) => { overlapped.RequestStop (); };

        Application.Iteration += (s, a) =>
                                 {
                                     if (iterations == 4)
                                     {
                                         // The Dialog was not closed before and will be closed now.
                                         Assert.True (Application.Current == d);
                                         Assert.False (d.Running);
                                     }
                                     else
                                     {
                                         Assert.Equal (iterations, Application.OverlappedChildren.Count);

                                         for (var i = 0; i < iterations; i++)
                                         {
                                             Assert.Equal ((iterations - i + 1).ToString (), Application.OverlappedChildren [i].Id);
                                         }
                                     }

                                     iterations--;
                                 };

        Application.Run (overlapped);

        Assert.Empty (Application.OverlappedChildren);
        Assert.NotNull (Application.OverlappedTop);
        Assert.NotNull (Application.Top);
        overlapped.Dispose ();
    }

    [Fact]
    [AutoInitShutdown]
    public void Visible_False_Does_Not_Clear ()
    {
        var overlapped = new Overlapped ();
        var win1 = new Window { Width = 5, Height = 5, Visible = false };
        var win2 = new Window { X = 1, Y = 1, Width = 5, Height = 5 };
        ((FakeDriver)Application.Driver).SetBufferSize (10, 10);
        RunState rsOverlapped = Application.Begin (overlapped);

        // Need to fool MainLoop into thinking it's running
        Application.MainLoop.Running = true;

        // RunIteration must be call on each iteration because
        // it's using the Begin and not the Run method
        var firstIteration = false;
        Application.RunIteration (ref rsOverlapped, ref firstIteration);

        Assert.Equal (overlapped, rsOverlapped.Toplevel);
        Assert.Equal (Application.Top, rsOverlapped.Toplevel);
        Assert.Equal (Application.OverlappedTop, rsOverlapped.Toplevel);
        Assert.Equal (Application.Current, rsOverlapped.Toplevel);
        Assert.Equal (overlapped, Application.Current);

        RunState rsWin1 = Application.Begin (win1);
        Application.RunIteration (ref rsOverlapped, ref firstIteration);

        Assert.Equal (overlapped, rsOverlapped.Toplevel);
        Assert.Equal (Application.Top, rsOverlapped.Toplevel);
        Assert.Equal (Application.OverlappedTop, rsOverlapped.Toplevel);
        // The win1 Visible is false and cannot be set as the Current
        Assert.Equal (Application.Current, rsOverlapped.Toplevel);
        Assert.Equal (overlapped, Application.Current);
        Assert.Equal (win1, rsWin1.Toplevel);

        RunState rsWin2 = Application.Begin (win2);
        Application.RunIteration (ref rsOverlapped, ref firstIteration);

        // Here the Current and the rsOverlapped.Toplevel is now the win2
        // and not the original overlapped
        Assert.Equal (win2, rsOverlapped.Toplevel);
        Assert.Equal (Application.Top, overlapped);
        Assert.Equal (Application.OverlappedTop, overlapped);
        Assert.Equal (Application.Current, rsWin2.Toplevel);
        Assert.Equal (win2, Application.Current);
        Assert.Equal (win1, rsWin1.Toplevel);

        // Tests that rely on visuals are too fragile. If border style changes they break.
        // Instead we should just rely on the test above.

        Application.OnMouseEvent (new MouseEvent { Position = new (1, 1), Flags = MouseFlags.Button1Pressed });
        Assert.Equal (win2.Border, Application.MouseGrabView);

        Application.RunIteration (ref rsOverlapped, ref firstIteration);

        Assert.Equal (win2, rsOverlapped.Toplevel);
        Assert.Equal (Application.Top, overlapped);
        Assert.Equal (Application.OverlappedTop, overlapped);
        Assert.Equal (Application.Current, rsWin2.Toplevel);
        Assert.Equal (win2, Application.Current);
        Assert.Equal (win1, rsWin1.Toplevel);

        Application.OnMouseEvent (new MouseEvent
        {
            Position = new (2, 2), Flags = MouseFlags.Button1Pressed | MouseFlags.ReportMousePosition
        });

        Application.RunIteration (ref rsOverlapped, ref firstIteration);

        Assert.Equal (win2, rsOverlapped.Toplevel);
        Assert.Equal (Application.Top, overlapped);
        Assert.Equal (Application.OverlappedTop, overlapped);
        Assert.Equal (Application.Current, rsWin2.Toplevel);
        Assert.Equal (win2, Application.Current);
        Assert.Equal (win1, rsWin1.Toplevel);

        // Tests that rely on visuals are too fragile. If border style changes they break.
        // Instead we should just rely on the test above.

        // This will end the win2 and not the overlapped
        Application.End (rsOverlapped);
        // rsOverlapped has been disposed and Toplevel property is null
        // So we must use another valid RunState to iterate
        Application.RunIteration (ref rsWin1, ref firstIteration);
#if DEBUG_IDISPOSABLE
        Assert.True (rsOverlapped.WasDisposed);
#endif
        Assert.Null (rsOverlapped.Toplevel);
        Assert.Equal (Application.Top, overlapped);
        Assert.Equal (Application.OverlappedTop, overlapped);
        Assert.Equal (Application.Current, rsWin1.Toplevel);
        Assert.Equal (win1, Application.Current);
        Assert.Equal (win1, rsWin1.Toplevel);

        Application.End (rsWin1);
        // rsWin1 has been disposed and Toplevel property is null
        // So we must use another valid RunState to iterate
        Application.RunIteration (ref rsWin2, ref firstIteration);
#if DEBUG_IDISPOSABLE
        Assert.True (rsOverlapped.WasDisposed);
        Assert.True (rsWin1.WasDisposed);
#endif
        Assert.Null (rsOverlapped.Toplevel);
        Assert.Equal (Application.Top, overlapped);
        Assert.Equal (Application.OverlappedTop, overlapped);
        Assert.Equal (Application.Current, overlapped);
        Assert.Null (rsWin1.Toplevel);
        // See here that the only Toplevel that needs to End is the overlapped
        // which the rsWin2 now has the Toplevel set to the overlapped
        Assert.Equal (overlapped, rsWin2.Toplevel);

        Application.End (rsWin2);
        // There is no more RunState to iteration
#if DEBUG_IDISPOSABLE
        Assert.True (rsOverlapped.WasDisposed);
        Assert.True (rsWin1.WasDisposed);
        Assert.True (rsWin2.WasDisposed);
#endif
        Assert.Null (rsOverlapped.Toplevel);
        Assert.Equal (Application.Top, overlapped);
        Assert.Equal (Application.OverlappedTop, overlapped);
        Assert.Null (Application.Current);
        Assert.Null (rsWin1.Toplevel);
        Assert.Null (rsWin2.Toplevel);

#if DEBUG_IDISPOSABLE
        Assert.False (win2.WasDisposed);
        Assert.False (win1.WasDisposed);
        Assert.False (overlapped.WasDisposed);
#endif
        // Now dispose all them
        win2.Dispose ();
        win1.Dispose ();
        overlapped.Dispose ();
        Application.Shutdown ();
    }

    private class Overlapped : Toplevel
    {
        public Overlapped () { IsOverlappedContainer = true; }
    }

    [Fact]
    [AutoInitShutdown]
    public void KeyBindings_Command_With_OverlappedTop ()
    {
        Toplevel top = new ();
        Assert.Null (Application.OverlappedTop);
        top.IsOverlappedContainer = true;
        Application.Begin (top);
        Assert.Equal (Application.Top, Application.OverlappedTop);

        var isRunning = true;

        var win1 = new Window { Id = "win1", Width = Dim.Percent (50), Height = Dim.Fill () };
        var lblTf1W1 = new Label { Text = "Enter text in TextField on Win1:" };
        var tf1W1 = new TextField { X = Pos.Right (lblTf1W1) + 1, Width = Dim.Fill (), Text = "Text1 on Win1" };
        var lblTvW1 = new Label { Y = Pos.Bottom (lblTf1W1) + 1, Text = "Enter text in TextView on Win1:" };

        var tvW1 = new TextView
        {
            X = Pos.Left (tf1W1), Width = Dim.Fill (), Height = 2, Text = "First line Win1\nSecond line Win1"
        };
        var lblTf2W1 = new Label { Y = Pos.Bottom (lblTvW1) + 1, Text = "Enter text in TextField on Win1:" };
        var tf2W1 = new TextField { X = Pos.Left (tf1W1), Width = Dim.Fill (), Text = "Text2 on Win1" };
        win1.Add (lblTf1W1, tf1W1, lblTvW1, tvW1, lblTf2W1, tf2W1);

        var win2 = new Window { Id = "win2", Width = Dim.Percent (50), Height = Dim.Fill () };
        var lblTf1W2 = new Label { Text = "Enter text in TextField on Win2:" };
        var tf1W2 = new TextField { X = Pos.Right (lblTf1W2) + 1, Width = Dim.Fill (), Text = "Text1 on Win2" };
        var lblTvW2 = new Label { Y = Pos.Bottom (lblTf1W2) + 1, Text = "Enter text in TextView on Win2:" };

        var tvW2 = new TextView
        {
            X = Pos.Left (tf1W2), Width = Dim.Fill (), Height = 2, Text = "First line Win1\nSecond line Win2"
        };
        var lblTf2W2 = new Label { Y = Pos.Bottom (lblTvW2) + 1, Text = "Enter text in TextField on Win2:" };
        var tf2W2 = new TextField { X = Pos.Left (tf1W2), Width = Dim.Fill (), Text = "Text2 on Win2" };
        win2.Add (lblTf1W2, tf1W2, lblTvW2, tvW2, lblTf2W2, tf2W2);

        win1.Closing += (s, e) => isRunning = false;
        Assert.Null (top.Focused);
        Assert.Equal (top, Application.Current);
        Assert.True (top.IsCurrentTop);
        Assert.Equal (top, Application.OverlappedTop);
        Application.Begin (win1);
        Assert.Equal (new (0, 0, 40, 25), win1.Frame);
        Assert.NotEqual (top, Application.Current);
        Assert.False (top.IsCurrentTop);
        Assert.Equal (win1, Application.Current);
        Assert.True (win1.IsCurrentTop);
        Assert.True (win1.IsOverlapped);
        Assert.Null (top.Focused);
        Assert.Null (top.MostFocused);
        Assert.Equal (tf1W1, win1.MostFocused);
        Assert.True (win1.IsOverlapped);
        Assert.Single (Application.OverlappedChildren);
        Application.Begin (win2);
        Assert.Equal (new (0, 0, 40, 25), win2.Frame);
        Assert.NotEqual (top, Application.Current);
        Assert.False (top.IsCurrentTop);
        Assert.Equal (win2, Application.Current);
        Assert.True (win2.IsCurrentTop);
        Assert.True (win2.IsOverlapped);
        Assert.Null (top.Focused);
        Assert.Null (top.MostFocused);
        Assert.Equal (tf1W2, win2.MostFocused);
        Assert.Equal (2, Application.OverlappedChildren.Count);

        Application.MoveToOverlappedChild (win1);
        Assert.Equal (win1, Application.Current);
        Assert.Equal (win1, Application.OverlappedChildren [0]);
        win1.Running = true;
        Assert.True (Application.OnKeyDown (Application.QuitKey));
        Assert.False (isRunning);
        Assert.False (win1.Running);
        Assert.Equal (win1, Application.OverlappedChildren [0]);

        Assert.True (
                     Application.OnKeyDown (Key.Z.WithCtrl)
                    );

        Assert.True (Application.OnKeyDown (Key.F5)); // refresh

        Assert.True (Application.OnKeyDown (Key.Tab));
        Assert.True (win1.IsCurrentTop);
        Assert.Equal (tvW1, win1.MostFocused);
        Assert.True (Application.OnKeyDown (Key.Tab));
        Assert.Equal ($"\tFirst line Win1{Environment.NewLine}Second line Win1", tvW1.Text);

        Assert.True (
                     Application.OnKeyDown (Key.Tab.WithShift)
                    );
        Assert.Equal ($"First line Win1{Environment.NewLine}Second line Win1", tvW1.Text);

        Assert.True (
                     Application.OnKeyDown (Key.Tab.WithCtrl)
                    );
        Assert.Equal (win1, Application.OverlappedChildren [0]);
        Assert.Equal (tf2W1, win1.MostFocused);
        Assert.True (Application.OnKeyDown (Key.Tab));
        Assert.Equal (win1, Application.OverlappedChildren [0]);
        Assert.Equal (tf1W1, win1.MostFocused);
        Assert.True (Application.OnKeyDown (Key.CursorRight));
        Assert.Equal (win1, Application.OverlappedChildren [0]);
        Assert.Equal (tf1W1, win1.MostFocused);
        Assert.True (Application.OnKeyDown (Key.CursorDown));
        Assert.Equal (win1, Application.OverlappedChildren [0]);
        Assert.Equal (tvW1, win1.MostFocused);
#if UNIX_KEY_BINDINGS
        Assert.True (Application.OverlappedChildren [0].ProcessKeyDown (new (Key.I.WithCtrl)));
        Assert.Equal (win1, Application.OverlappedChildren [0]);
        Assert.Equal (tf2W1, win1.MostFocused);
#endif
        Assert.True (
                     Application.OverlappedChildren [0]
                                .NewKeyDownEvent (Key.Tab.WithShift)
                    );
        Assert.Equal (win1, Application.OverlappedChildren [0]);
        Assert.Equal (tvW1, win1.MostFocused);
        Assert.True (Application.OnKeyDown (Key.CursorLeft));
        Assert.Equal (win1, Application.OverlappedChildren [0]);
        Assert.Equal (tf1W1, win1.MostFocused);
        Assert.True (Application.OnKeyDown (Key.CursorUp));
        Assert.Equal (win1, Application.OverlappedChildren [0]);
        Assert.Equal (tf2W1, win1.MostFocused);
        Assert.True (Application.OnKeyDown (Key.Tab));
        Assert.Equal (win1, Application.OverlappedChildren [0]);
        Assert.Equal (tf1W1, win1.MostFocused);

        Assert.True (
                     Application.OverlappedChildren [0]
                                .NewKeyDownEvent (Key.Tab.WithCtrl)
                    );
        Assert.Equal (win2, Application.OverlappedChildren [0]);
        Assert.Equal (tf1W2, win2.MostFocused);
        tf2W2.SetFocus ();
        Assert.True (tf2W2.HasFocus);

        Assert.True (
                     Application.OverlappedChildren [0]
                                .NewKeyDownEvent (Key.Tab.WithCtrl.WithShift)
                    );
        Assert.Equal (win1, Application.OverlappedChildren [0]);
        Assert.Equal (tf1W1, win1.MostFocused);
        Assert.True (Application.OnKeyDown (Application.AlternateForwardKey));
        Assert.Equal (win2, Application.OverlappedChildren [0]);
        Assert.Equal (tf2W2, win2.MostFocused);
        Assert.True (Application.OnKeyDown (Application.AlternateBackwardKey));
        Assert.Equal (win1, Application.OverlappedChildren [0]);
        Assert.Equal (tf1W1, win1.MostFocused);
        Assert.True (Application.OnKeyDown (Key.CursorDown));
        Assert.Equal (win1, Application.OverlappedChildren [0]);
        Assert.Equal (tvW1, win1.MostFocused);
#if UNIX_KEY_BINDINGS
        Assert.True (Application.OverlappedChildren [0].ProcessKeyDown (new (Key.B.WithCtrl)));
#else
        Assert.True (Application.OnKeyDown (Key.CursorLeft));
#endif
        Assert.Equal (win1, Application.OverlappedChildren [0]);
        Assert.Equal (tf1W1, win1.MostFocused);
        Assert.True (Application.OnKeyDown (Key.CursorDown));
        Assert.Equal (win1, Application.OverlappedChildren [0]);
        Assert.Equal (tvW1, win1.MostFocused);
        Assert.Equal (Point.Empty, tvW1.CursorPosition);

        Assert.True (
                     Application.OverlappedChildren [0]
                                .NewKeyDownEvent (Key.End.WithCtrl)
                    );
        Assert.Equal (win1, Application.OverlappedChildren [0]);
        Assert.Equal (tvW1, win1.MostFocused);
        Assert.Equal (new (16, 1), tvW1.CursorPosition);
#if UNIX_KEY_BINDINGS
        Assert.True (Application.OverlappedChildren [0].ProcessKeyDown (new (Key.F.WithCtrl)));
#else
        Assert.True (Application.OnKeyDown (Key.CursorRight));
#endif
        Assert.Equal (win1, Application.OverlappedChildren [0]);
        Assert.Equal (tf2W1, win1.MostFocused);

#if UNIX_KEY_BINDINGS
        Assert.True (Application.OverlappedChildren [0].ProcessKeyDown (new (Key.L.WithCtrl)));
#endif
        win2.Dispose ();
        win1.Dispose ();
        top.Dispose ();
    }
}