mirror of
https://github.com/gui-cs/Terminal.Gui.git
synced 2025-12-26 15:57:56 +01:00
1010 lines
41 KiB
C#
1010 lines
41 KiB
C#
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);
|
|
}
|
|
|
|
[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);
|
|
}
|
|
|
|
[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);
|
|
}
|
|
|
|
[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);
|
|
}
|
|
|
|
[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);
|
|
}
|
|
|
|
[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);
|
|
}
|
|
|
|
[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);
|
|
}
|
|
|
|
[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);
|
|
}
|
|
|
|
[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);
|
|
}
|
|
|
|
[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);
|
|
}
|
|
|
|
[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);
|
|
}
|
|
|
|
[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 { X = 1, Y = 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
|
|
{
|
|
X = 2,
|
|
Y = 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; }
|
|
}
|
|
}
|